package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleDetailReq;
import com.wicket.okrapp.base.service.dto.req.QueryPlanEvaBatchSetDetailReq;
import com.wicket.okrapp.biz.service.TargetCycleService;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.ImplementLoopAddAncestorContTargetCycleBudgetDataComReqDto;
import com.wicket.okrapp.biz.service.dto.req.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.biz.service.dto.req.QuerySubmitFinanceStandardDataDetailComReqDto;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.biz.service.dto.res.ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto;
import com.wicket.okrapp.biz.service.dto.res.QuerySubmitFinanceStandardDataDetailComRespDto;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;

import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrapp.dal.po.mbg.OmsEvaBatchRelatedSet;
import com.wicket.okrcalc.integration.FwCalcStandardDataClient;
import com.wicket.okrcalc.integration.dto.*;
import com.wicket.okrcalc.integration.dto.QueryStandardDataDetailComReqDto;
import com.wicket.okrcalc.integration.dto.QueryStandardDataDetailComRespDto;
import com.wicket.okrcomponent.integration.dto.*;
//import com.wicket.okrcomponent.integration.dto.DataSetsListOneDto;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerListComReqDto;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbStandardData;
import com.wicket.okrcomponent.integration.FwCompConfSchemeClient;
import com.wicket.okrapp.base.service.MOmsCycleService;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.biz.service.dto.common.ProcessExceuteCycleStageDto;
import java.util.ArrayList;

import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrapp.biz.service.CycleTypeService;
import com.wicket.okrcomponent.integration.FwCompInterfaceModeClient;
import com.wicket.okrapp.dal.po.mbg.OmsCycle;
import com.wicket.okrapp.base.service.dto.req.BatchQueryRightProcessCycleByCodeListByCodesReq;
import com.wicket.okrapp.base.service.MOmsEvaBatchRelatedSetService;
import com.wicket.okrapp.base.service.dto.common.StandardDataDto;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;
import com.wicket.okrapp.dal.po.mbg.OmsExecuteCycleStage;
import com.wicket.okrapp.base.service.dto.req.QueryExecuteCycleStageDetailReq;
import com.wicket.okrapp.biz.service.IndexSystemService;
import com.wicket.okrcalc.integration.FwCalcTargetCycleClient;
import com.wicket.okrapp.biz.service.TargetContentService;
import com.wicket.okrapp.biz.service.CycleStageDataService;
import com.wicket.okrapp.biz.service.GridCalculateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.biz.service.ExecuteCycleService;
import com.wicket.okrapp.biz.service.VirtualOrgService;
import com.wicket.okrapp.biz.service.EvaThemeService;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleListReq;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrapp.base.service.MOmsTspeCycleStageDataService;
import com.wicket.okrapp.dal.po.mbg.OmsTspeCycleStageData;
import com.wicket.okrapp.base.service.dto.req.QueryCycleStageDataDetailReq;
import com.wicket.okrapp.biz.service.dto.common.FinanceAccountDto;
import com.wicket.okrfinance.integration.dto.QueryFinanceAccountDetailComRespDto;
import com.wicket.okrfinance.integration.dto.QueryFinanceAccountDetailComReqDto;
import com.wicket.okrfinance.integration.FwFinanceFinanceClient;
import com.wicket.okrapp.biz.service.TaskService;
import com.wicket.okrapp.biz.service.dto.common.LookAncestorNodeDto;
import com.wicket.okrapp.biz.service.FinanceService;
import com.wicket.okrapp.base.service.MOmsTargetObjectiveService;
import com.wicket.okrcomponent.integration.FwCompStandardDataClient;
import com.wicket.okrfinance.integration.dto.QueryFullTemplateFundAccountListComRespDto;
import com.wicket.okrfinance.integration.dto.QueryFullTemplateFundAccountListComReqDto;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationTemplate;
import com.wicket.okrapp.base.service.dto.req.QueryEvaTempDetailReq;
import com.wicket.okrapp.base.service.MOmsEvaObjTargetCycleWeightSetService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaObjTargetCycleWeightSet;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleWeightDetailReq;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.biz.service.TargetCalcService;
import com.wicket.okrapp.base.service.MOmsTargetAttributionCycleService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetAttributionCycle;
import com.wicket.okrapp.base.service.dto.req.QueryTargetBelongCycleDetailReq;
import com.wicket.okrapp.base.service.dto.req.QueryTargetContetCycleDetailReq;
import com.wicket.okrfinance.integration.dto.QueryAccountSubjectDetailComRespDto;
import com.wicket.okrfinance.integration.dto.QueryAccountSubjectDetailComReqDto;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class StandardDataServiceImpl
  implements com.wicket.okrapp.biz.service.StandardDataService {

  @Resource
  private RedisUtil redisUtil;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
@Resource
  private NbStandardData nbStandardData;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private MOmsCycleService mOmsCycleService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private CycleTypeService cycleTypeService;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private TargetCycleService targetCycleService;
@Resource
  private FwCalcStandardDataClient fwCalcStandardDataClient;
@Resource
  private MOmsEvaBatchRelatedSetService mOmsEvaBatchRelatedSetService;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private FwCalcTargetCycleClient fwCalcTargetCycleClient;
@Resource
  private TargetContentService targetContentService;
@Resource
  private CycleStageDataService cycleStageDataService;
@Resource
  private GridCalculateService gridCalculateService;
@Resource
  private ExecuteCycleService executeCycleService;
@Resource
  private VirtualOrgService virtualOrgService;
@Resource
  private EvaThemeService evaThemeService;
//@Resource
 //private MOmsAccountService mOmsAccountService;
@Resource
  private MOmsTspeCycleStageDataService mOmsTspeCycleStageDataService;
//@Resource
 //private MMmmShellService mMmmShellService;
@Resource
  private FwFinanceFinanceClient fwFinanceFinanceClient;
@Resource
  private TaskService taskService;
//@Resource
 //private MCustomFields4Service mCustomFields4Service;
@Resource
  private FinanceService financeService;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
@Resource
  private FwCompStandardDataClient fwCompStandardDataClient;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private MOmsEvaObjTargetCycleWeightSetService mOmsEvaObjTargetCycleWeightSetService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
//@Resource
 //private MSpecMethordTableService mSpecMethordTableService;
//@Resource
 //private undefinedService undefinedService;

/**
   * D3-查询得分权重准备详情(公共)[6010]
   * gen by moon at 3/3/2023, 11:44:28 PM
   */
  @Trace(operationName = "D3-查询得分权重准备详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryPrepareForScoreWeightDetailComRespDto queryPrepareForScoreWeightDetailCom(QueryPrepareForScoreWeightDetailComReqDto reqDto){


//      ImplementAccessParameterBizFieldRespDto receptionServiceRes_1 =null;
//if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("SUB_CYCLE"))) {
//        //if(D3-查询得分权重准备详情(公共).父子中周期类型 等于 子周期)  31802
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto.setConfItemCode("SUB_PROCESS_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720224_1_31803
//queryItemMatchResultOptionToAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:720226_1_31803
//queryItemMatchResultOptionToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:720227_1_31803
//queryItemMatchResultOptionToAnswerDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720229_1_31803
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720225_1_31803
//    }
//
//    /*D2-3查子周期过程汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查子周期过程汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_2 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_1=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_1.setConfItemCode("SUB_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720290_1_31804
//queryItemMatchResultOptionToAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:720292_1_31804
//queryItemMatchResultOptionToAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:720293_1_31804
//queryItemMatchResultOptionToAnswerDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720295_1_31804
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720291_1_31804
//    }
//
//    /*D2-查子周期汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_1.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-查子周期汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_1).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_4 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_2=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_2.setConfItemCode("SUB_ACTUAL_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720273_1_31805
//queryItemMatchResultOptionToAnswerDetailComReqDto_2.setResultAspObjType("EVA_TEMP");//sourceId:720275_1_31805
//queryItemMatchResultOptionToAnswerDetailComReqDto_2.setIsPlatData("FALSE");//sourceId:720276_1_31805
//queryItemMatchResultOptionToAnswerDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720278_1_31805
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_2.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720274_1_31805
//    }
//
//    /*D2-3查子周期实际得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_2.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查子周期实际得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_4 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_2).getData();
//
//
//
////ModelCode: receptionService
//        ImplementAccessParameterBizFieldRespDto receptionServiceRes = null;
//    if(queryItemMatchResultOptionToAnswerDetailComRespDto !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_2 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_4 !=null){
//          ImplementAccessParameterBizFieldReqDto receptionServiceReq=new ImplementAccessParameterBizFieldReqDto();
//  if(queryItemMatchResultOptionToAnswerDetailComRespDto!=null){
//      receptionServiceReq.setProcessMidWeight(queryItemMatchResultOptionToAnswerDetailComRespDto.getProcessMidWeight());//SimpleFieldAssign//sourceId:720704_1_31836
//receptionServiceReq.setReportAvgScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720705_1_31836
//receptionServiceReq.setKrWeight(queryItemMatchResultOptionToAnswerDetailComRespDto.getKrWeight());//SimpleFieldAssign//sourceId:720706_1_31836
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_2!=null){
//      receptionServiceReq.setProcessReportScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_2.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720707_1_31836
//receptionServiceReq.setSubjectiveAndObjectiveScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_2.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720708_1_31836
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_4!=null){
//      receptionServiceReq.setLocalLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_4.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720709_1_31836
//receptionServiceReq.setLowerLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_4.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720710_1_31836
//    }
//
//    /*统一出参[5797]  用于特殊方法接收上游入参。 */
//
//      receptionServiceRes = nbStandardData.implementAccessParameterBizField(receptionServiceReq);
//
//
//      receptionServiceRes_1 = receptionServiceRes;
//           }
//      }
//else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("MID_CYCLE"))){
//       //elseif(D3-查询得分权重准备详情(公共).父子中周期类型 等于 中期)  31806
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_6 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_3=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_3.setConfItemCode("MID_PROCESS_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720311_1_31807
//queryItemMatchResultOptionToAnswerDetailComReqDto_3.setResultAspObjType("EVA_TEMP");//sourceId:720313_1_31807
//queryItemMatchResultOptionToAnswerDetailComReqDto_3.setIsPlatData("FALSE");//sourceId:720314_1_31807
//queryItemMatchResultOptionToAnswerDetailComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720316_1_31807
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_3.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720312_1_31807
//    }
//
//    /*D2-3查中期过程汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_3.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查中期过程汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_6 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_3).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_8 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_4=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_4.setConfItemCode("MID_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720328_1_31808
//queryItemMatchResultOptionToAnswerDetailComReqDto_4.setResultAspObjType("EVA_TEMP");//sourceId:720330_1_31808
//queryItemMatchResultOptionToAnswerDetailComReqDto_4.setIsPlatData("FALSE");//sourceId:720331_1_31808
//queryItemMatchResultOptionToAnswerDetailComReqDto_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720333_1_31808
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_4.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720329_1_31808
//    }
//
//    /*D2-3查中期汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_4.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查中期汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_8 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_4).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_10 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_5=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_5.setConfItemCode("MID_ACTUAL_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720345_1_31809
//queryItemMatchResultOptionToAnswerDetailComReqDto_5.setResultAspObjType("EVA_TEMP");//sourceId:720347_1_31809
//queryItemMatchResultOptionToAnswerDetailComReqDto_5.setIsPlatData("FALSE");//sourceId:720348_1_31809
//queryItemMatchResultOptionToAnswerDetailComReqDto_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720350_1_31809
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_5.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720346_1_31809
//    }
//
//    /*D2-3查中期实际得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_5.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查中期实际得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_10 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_5).getData();
//
//
//
////ModelCode: receptionService
//        ImplementAccessParameterBizFieldRespDto receptionServiceRes_2 = null;
//    if(queryItemMatchResultOptionToAnswerDetailComRespDto_6 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_8 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_10 !=null){
//          ImplementAccessParameterBizFieldReqDto receptionServiceReq_1=new ImplementAccessParameterBizFieldReqDto();
//  if(queryItemMatchResultOptionToAnswerDetailComRespDto_6!=null){
//      receptionServiceReq_1.setReportAvgScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_6.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720705_1_31838
//receptionServiceReq_1.setKrWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_6.getKrWeight());//SimpleFieldAssign//sourceId:720706_1_31838
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_8!=null){
//      receptionServiceReq_1.setProcessReportScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_8.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720707_1_31838
//receptionServiceReq_1.setSubjectiveAndObjectiveScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_8.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720708_1_31838
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_10!=null){
//      receptionServiceReq_1.setLocalLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_10.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720709_1_31838
//receptionServiceReq_1.setLowerLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_10.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720710_1_31838
//    }
//
//    /*统一出参[5797]  用于特殊方法接收上游入参。 */
//
//      receptionServiceRes_2 = nbStandardData.implementAccessParameterBizField(receptionServiceReq_1);
//
//
//      receptionServiceRes_1 = receptionServiceRes_2;
//           }
//    }
//else if((reqDto!= null&&  reqDto.getParentSubMidCycleType() !=null && reqDto.getParentSubMidCycleType().equals("PARENT_CYCLE"))){
//       //elseif(D3-查询得分权重准备详情(公共).父子中周期类型 等于 父周期)  31810
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_12 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_6=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_6.setConfItemCode("FATHER_PROCESS_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720362_1_31811
//queryItemMatchResultOptionToAnswerDetailComReqDto_6.setResultAspObjType("EVA_TEMP");//sourceId:720364_1_31811
//queryItemMatchResultOptionToAnswerDetailComReqDto_6.setIsPlatData("FALSE");//sourceId:720365_1_31811
//queryItemMatchResultOptionToAnswerDetailComReqDto_6.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720367_1_31811
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_6.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720363_1_31811
//    }
//
//    /*D2-3查父周期过程汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_6.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查父周期过程汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_12 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_6).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_14 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_7=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_7.setConfItemCode("FATHER_REPORT_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720379_1_31812
//queryItemMatchResultOptionToAnswerDetailComReqDto_7.setResultAspObjType("EVA_TEMP");//sourceId:720381_1_31812
//queryItemMatchResultOptionToAnswerDetailComReqDto_7.setIsPlatData("FALSE");//sourceId:720382_1_31812
//queryItemMatchResultOptionToAnswerDetailComReqDto_7.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720384_1_31812
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_7.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720380_1_31812
//    }
//
//    /*D2-3查父周期汇报得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getConfItemCode(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-配置项标识不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getIsPlatData(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-是否标准答案不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_7.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查父周期汇报得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_14 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_7).getData();
//
//
//
//QueryItemMatchResultOptionToAnswerDetailComRespDto queryItemMatchResultOptionToAnswerDetailComRespDto_16 = null;
//    QueryItemMatchResultOptionToAnswerDetailComReqDto queryItemMatchResultOptionToAnswerDetailComReqDto_8=new QueryItemMatchResultOptionToAnswerDetailComReqDto();
//  queryItemMatchResultOptionToAnswerDetailComReqDto_8.setConfItemCode("FATHER_ACTUAL_SCORE_WEIGHT");//CUSTOM_CONVENTION//sourceId:720396_1_31813
//queryItemMatchResultOptionToAnswerDetailComReqDto_8.setResultAspObjType("EVA_TEMP");//sourceId:720398_1_31813
//queryItemMatchResultOptionToAnswerDetailComReqDto_8.setIsPlatData("FALSE");//sourceId:720399_1_31813
//queryItemMatchResultOptionToAnswerDetailComReqDto_8.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:720401_1_31813
//if(reqDto!=null){
//      queryItemMatchResultOptionToAnswerDetailComReqDto_8.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:720397_1_31813
//    }
//
//    /*D2-3查父周期实际得分权重[5991]   */
//    Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_8.getResultAspObjId(),"D3-查询得分权重准备详情(公共)-D2-3查父周期实际得分权重-答案归属对象ID不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_8.getResultAspObjType(),"D3-查询得分权重准备详情(公共)-D2-3查父周期实际得分权重-答案归属对象类型不能为空",false);
//Assert.isNull(queryItemMatchResultOptionToAnswerDetailComReqDto_8.getSubjectLifeCycle(),"D3-查询得分权重准备详情(公共)-D2-3查父周期实际得分权重-主体生命周期不能为空",false);
//      queryItemMatchResultOptionToAnswerDetailComRespDto_16 = fwCompConfSchemeClient.queryItemMatchResultOptionToAnswerDetailCom(queryItemMatchResultOptionToAnswerDetailComReqDto_8).getData();
//
//
//
////ModelCode: receptionService
//        ImplementAccessParameterBizFieldRespDto receptionServiceRes_3 = null;
//    if(queryItemMatchResultOptionToAnswerDetailComRespDto_12 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_14 !=null&&queryItemMatchResultOptionToAnswerDetailComRespDto_16 !=null){
//          ImplementAccessParameterBizFieldReqDto receptionServiceReq_2=new ImplementAccessParameterBizFieldReqDto();
//  if(queryItemMatchResultOptionToAnswerDetailComRespDto_12!=null){
//      receptionServiceReq_2.setMidReportWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_12.getMidReportWeight());//SimpleFieldAssign//sourceId:720711_1_31839
//receptionServiceReq_2.setReportAvgScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_12.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720705_1_31839
//receptionServiceReq_2.setKrWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_12.getKrWeight());//SimpleFieldAssign//sourceId:720706_1_31839
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_14!=null){
//      receptionServiceReq_2.setProcessReportScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_14.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720707_1_31839
//receptionServiceReq_2.setSubjectiveAndObjectiveScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_14.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720708_1_31839
//    }
//if(queryItemMatchResultOptionToAnswerDetailComRespDto_16!=null){
//      receptionServiceReq_2.setLocalLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_16.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720709_1_31839
//receptionServiceReq_2.setLowerLevelScoreWeight(queryItemMatchResultOptionToAnswerDetailComRespDto_16.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720710_1_31839
//    }
//
//    /*统一出参[5797]  用于特殊方法接收上游入参。 */
//
//      receptionServiceRes_3 = nbStandardData.implementAccessParameterBizField(receptionServiceReq_2);
//
//
//      receptionServiceRes_1 = receptionServiceRes_3;
//           }
//    }
QueryPrepareForScoreWeightDetailComRespDto retData = new QueryPrepareForScoreWeightDetailComRespDto();
//  if(receptionServiceRes_1!=null){
//      retData.setProcessMidWeight(receptionServiceRes_1.getProcessMidWeight());//SimpleFieldAssign//sourceId:720722_1
//retData.setReportAvgScoreWeight(receptionServiceRes_1.getReportAvgScoreWeight());//SimpleFieldAssign//sourceId:720723_1
//retData.setKrWeight(receptionServiceRes_1.getKrWeight());//SimpleFieldAssign//sourceId:720724_1
//retData.setProcessReportScoreWeight(receptionServiceRes_1.getProcessReportScoreWeight());//SimpleFieldAssign//sourceId:720725_1
//retData.setSubjectiveAndObjectiveScoreWeight(receptionServiceRes_1.getSubjectiveAndObjectiveScoreWeight());//SimpleFieldAssign//sourceId:720726_1
//retData.setLocalLevelScoreWeight(receptionServiceRes_1.getLocalLevelScoreWeight());//SimpleFieldAssign//sourceId:720727_1
//retData.setLowerLevelScoreWeight(receptionServiceRes_1.getLowerLevelScoreWeight());//SimpleFieldAssign//sourceId:720728_1
//retData.setMidReportWeight(receptionServiceRes_1.getMidReportWeight());//SimpleFieldAssign//sourceId:720729_1
//    }




return retData;
  }
/**
   * D3-执行当前及向右分析过程周期（公共）[6067]
   * gen by moon at 4/26/2023, 9:53:46 PM
   */
  @Trace(operationName = "D3-执行当前及向右分析过程周期（公共）")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementPercentageGrowthDeclineStandardDataComRespDto implementPercentageGrowthDeclineStandardDataCom(ImplementPercentageGrowthDeclineStandardDataComReqDto reqDto){


      ImplementFatherCycleTypeAnalysisComRespDto implementFatherCycleTypeAnalysisComRespDto_1 =null;
      ImplementAcceptAboveFieldsRespDto receptionServiceRes_1 =null;
//virtualUsage D3-3查当前及向右全量周期类型  32682
      ImplementFatherCycleTypeAnalysisComRespDto implementFatherCycleTypeAnalysisComRespDto = null;
    ImplementFatherCycleTypeAnalysisComReqDto implementFatherCycleTypeAnalysisComReqDto=new ImplementFatherCycleTypeAnalysisComReqDto();
  if(reqDto!=null){
      implementFatherCycleTypeAnalysisComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:754503_1_32682
      implementFatherCycleTypeAnalysisComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:744561_1_32682
implementFatherCycleTypeAnalysisComReqDto.setCycleTypeCode(reqDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:754477_1_32682
implementFatherCycleTypeAnalysisComReqDto.setFatherMidSubCycleDataModel(reqDto.getFatherMidSubCycleDataModel());//SimpleFieldAssign//sourceId:744566_1_32682
implementFatherCycleTypeAnalysisComReqDto.setFatherCycleType(reqDto.getFatherCycleType());//SimpleFieldAssign//sourceId:744559_1_32682
implementFatherCycleTypeAnalysisComReqDto.setMidCycleType(reqDto.getMidCycleType());//SimpleFieldAssign//sourceId:744560_1_32682
implementFatherCycleTypeAnalysisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:744558_1_32682
    }

    /*D3-3查当前及向右全量周期类型[5862]   */
    Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getEvaObjTargetCycleId(),"D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-被评对象目标周期ID不能为空",false);
Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getCycleId(),"D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-周期ID不能为空",false);
Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getCycleTypeCode(),"D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-周期类型标识不能为空",false);
Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getFatherCycleType(),"D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-父周期周期类型不能为空",false);
Assert.isNull(implementFatherCycleTypeAnalysisComReqDto.getEvaluationTemplateId(),"D3-执行当前及向右分析过程周期（公共）-D3-3查当前及向右全量周期类型-冗余评价模板ID不能为空",false);
      implementFatherCycleTypeAnalysisComRespDto = cycleTypeService.implementFatherCycleTypeAnalysisCom(implementFatherCycleTypeAnalysisComReqDto)/*vcase invoke isSameApp*/;


      implementFatherCycleTypeAnalysisComRespDto_1 = implementFatherCycleTypeAnalysisComRespDto;
if((implementFatherCycleTypeAnalysisComRespDto!= null&&  implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList() !=null && implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList().size()>0)) {
        //if(D3-3查当前及向右全量周期类型.周期类型列表数据集条数 大于 0)  32683

QueryConfItemMatchAnswerListComRespDto queryConfItemMatchAnswerListComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerListComReqDto queryConfItemMatchAnswerListComReqDto=new QueryConfItemMatchAnswerListComReqDto();
  queryConfItemMatchAnswerListComReqDto.setConfItemCode("PROCESS_STAGE_CYCLE_TYPE");//CUSTOM_CONVENTION//sourceId:744568_1_32684
queryConfItemMatchAnswerListComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:744569_1_32684
queryConfItemMatchAnswerListComReqDto.setIsPlatData("FALSE");//sourceId:744571_1_32684
if(reqDto!=null){
      queryConfItemMatchAnswerListComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:744570_1_32684
    }

    /*D2-3查过程周期类型列表[2505]   */
    Assert.isNull(queryConfItemMatchAnswerListComReqDto.getResultAspObjId(),"D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-答案归属对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getConfItemCode(),"D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getResultAspObjType(),"D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-答案归属对象类型不能为空",false);
Assert.isNull(queryConfItemMatchAnswerListComReqDto.getIsPlatData(),"D3-执行当前及向右分析过程周期（公共）-D2-3查过程周期类型列表-是否标准答案不能为空",false);
      queryConfItemMatchAnswerListComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerListCom(queryConfItemMatchAnswerListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementUniteMultipleManyFieldsDataSetsComRespDto implementUniteMultipleManyFieldsDataSetsComRespDto = null;
    if(implementFatherCycleTypeAnalysisComRespDto !=null&&queryConfItemMatchAnswerListComRespDto !=null){
          ImplementUniteMultipleManyFieldsDataSetsComReqDto implementUniteMultipleManyFieldsDataSetsComReqDto=new ImplementUniteMultipleManyFieldsDataSetsComReqDto();
  if(implementFatherCycleTypeAnalysisComRespDto!= null&&  implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList() !=null&& !CollectionUtil.isEmpty(implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList())){
      implementUniteMultipleManyFieldsDataSetsComReqDto.setDataSetsListOne(//objList-to-objLists
        implementFatherCycleTypeAnalysisComRespDto.getCycleTypeList().stream().map(item -> {
      com.wicket.okrcomponent.integration.dto.DataSetsListOneDto elm = new com.wicket.okrcomponent.integration.dto.DataSetsListOneDto();
      if(item!=null){
      elm.setCustomField(item.getCycleTypeCode());//SimpleFieldAssign//sourceId:168063_2_32685
elm.setComTxtField(item.getOrderNumber()!=null?String.valueOf(item.getOrderNumber()):"");//SimpleFieldAssign//sourceId:168064_2_32685
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:744586_1_32685
    }
if(queryConfItemMatchAnswerListComRespDto!= null&&  queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList() !=null&& !CollectionUtil.isEmpty(queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList())){
      implementUniteMultipleManyFieldsDataSetsComReqDto.setDataSetsListTwo(//objList-to-objLists
        queryConfItemMatchAnswerListComRespDto.getConfSchemeItemResultList().stream().map(item -> {
      DataSetsListTwoDto elm = new DataSetsListTwoDto();
      if(item!=null){
      elm.setCustomField(item.getEndValue());//SimpleFieldAssign//sourceId:168065_2_32685
elm.setCustomField1(item.getConfOptionSortNum()!=null?String.valueOf(item.getConfOptionSortNum()):"");//SimpleFieldAssign//sourceId:168066_2_32685
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:744587_1_32685
    }

    /*D2-筛选向右过程周期类型[5676]   */

      implementUniteMultipleManyFieldsDataSetsComRespDto = fwCompInterfaceModeClient.implementUniteMultipleManyFieldsDataSetsCom(implementUniteMultipleManyFieldsDataSetsComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementUniteMultipleManyFieldsDataSetsComRespDto!= null&&  implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList() !=null && implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList().size()>0)) {
        //if(D2-筛选向右过程周期类型.数据集交集列表数据集条数 大于 0)  32686

List<OmsCycle> listOmsCycle =new ArrayList<>();
    if(implementUniteMultipleManyFieldsDataSetsComRespDto !=null&&implementFatherCycleTypeAnalysisComRespDto !=null){
          BatchQueryRightProcessCycleByCodeListByCodesReq batchQueryRightProcessCycleByCodeListByCodesReq=new BatchQueryRightProcessCycleByCodeListByCodesReq();
  batchQueryRightProcessCycleByCodeListByCodesReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:745707_1_32713
if(implementUniteMultipleManyFieldsDataSetsComRespDto!= null&&  implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList() !=null&& !CollectionUtil.isEmpty(implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList())){
      batchQueryRightProcessCycleByCodeListByCodesReq.setCycleList(implementUniteMultipleManyFieldsDataSetsComRespDto.getCollectionsIntersectionsDataList().stream().map(item->item.getCustomField())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:745704_1_32713
    }
if(implementFatherCycleTypeAnalysisComRespDto!=null){
      batchQueryRightProcessCycleByCodeListByCodesReq.setCycleStartTime(implementFatherCycleTypeAnalysisComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:745705_1_32713
      batchQueryRightProcessCycleByCodeListByCodesReq.setCycleEndTime(implementFatherCycleTypeAnalysisComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:745706_1_32713
    }

    /*3-4-04查询向右过程周期列表ByCodes[6070]   */
    Assert.isNull(batchQueryRightProcessCycleByCodeListByCodesReq.getCycleStartTime(),"D3-执行当前及向右分析过程周期（公共）-3-4-04查询向右过程周期列表ByCodes-周期开始时间不能为空",false);
Assert.isNull(batchQueryRightProcessCycleByCodeListByCodesReq.getCycleEndTime(),"D3-执行当前及向右分析过程周期（公共）-3-4-04查询向右过程周期列表ByCodes-周期结束时间不能为空",false);
Assert.isNull(batchQueryRightProcessCycleByCodeListByCodesReq.getSubjectLifeCycle(),"D3-执行当前及向右分析过程周期（公共）-3-4-04查询向右过程周期列表ByCodes-主体生命周期不能为空",false);
      listOmsCycle = mOmsCycleService.batchQueryRightProcessCycleByCodeListByCodes(batchQueryRightProcessCycleByCodeListByCodesReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptAboveFieldsRespDto receptionServiceRes = null;
    if(listOmsCycle !=null&& !CollectionUtil.isEmpty(listOmsCycle)&& listOmsCycle.size()>0 ){
          ImplementAcceptAboveFieldsReqDto receptionServiceReq=new ImplementAcceptAboveFieldsReqDto();
  if(listOmsCycle!= null&& !CollectionUtil.isEmpty(listOmsCycle)&&  listOmsCycle !=null&& !CollectionUtil.isEmpty(listOmsCycle)){
      receptionServiceReq.setProcessExceuteCycleStageList(//objList-to-objLists
        listOmsCycle.stream().map(item -> {
      ProcessExceuteCycleStageDto elm = new ProcessExceuteCycleStageDto();
      elm.setCycleId(item.getCycleId());//SimpleFieldAssign//sourceId:168119_2_32705
if(reqDto!=null){
      elm.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:168120_2_32705
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:744969_1_32705
    }

    /*M3-将过程周期ID与目标周期ID合并成数据集[5897]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbStandardData.implementAcceptAboveFields(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
      }
ImplementPercentageGrowthDeclineStandardDataComRespDto retData = new ImplementPercentageGrowthDeclineStandardDataComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setProcessExceuteCycleStageList(receptionServiceRes_1.getProcessExceuteCycleStageList().stream().map(item -> BeanUtil.toBean(item, ProcessExceuteCycleStageDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:745938_1
    }
if(implementFatherCycleTypeAnalysisComRespDto_1!=null){
      retData.setLastEvaObjTargetCycleId(implementFatherCycleTypeAnalysisComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:754790_1
retData.setLastCycleId(implementFatherCycleTypeAnalysisComRespDto_1.getLastCycleId());//SimpleFieldAssign//sourceId:754791_1
    }




return retData;
  }
/**
   * 1111D3-执行提交汇报任务异常校验(公共)[6159]
   * gen by moon at 3/28/2023, 10:17:33 AM
   */
  @Trace(operationName = "1111D3-执行提交汇报任务异常校验(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCommitTaskReportCheckComRespDto implementCommitTaskReportCheckCom(ImplementCommitTaskReportCheckComReqDto reqDto){


      //virtualUsage 3-3-09-03查询评价模板批次设置详情  35045
      OmsEvaBatchRelatedSet omsEvaBatchRelatedSet = null;
    QueryPlanEvaBatchSetDetailReq queryPlanEvaBatchSetDetailReq=new QueryPlanEvaBatchSetDetailReq();
  queryPlanEvaBatchSetDetailReq.setBatchSetObjectType("TOP_EVA_TEMP_MGT");//sourceId:787430_1_35045
if(reqDto!=null){
      queryPlanEvaBatchSetDetailReq.setBatchSetId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:787429_1_35045
    }

    /*3-3-09-03查询评价模板批次设置详情[2998]   */
    Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetId(),"1111D3-执行提交汇报任务异常校验(公共)-3-3-09-03查询评价模板批次设置详情-批次设置对象ID不能为空",false);
Assert.isNull(queryPlanEvaBatchSetDetailReq.getBatchSetObjectType(),"1111D3-执行提交汇报任务异常校验(公共)-3-3-09-03查询评价模板批次设置详情-批次设置对象类型不能为空",false);
      omsEvaBatchRelatedSet = mOmsEvaBatchRelatedSetService.queryPlanEvaBatchSetDetail(queryPlanEvaBatchSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((!(omsEvaBatchRelatedSet!= null&&  omsEvaBatchRelatedSet.getUsingLockStatus() !=null && omsEvaBatchRelatedSet.getUsingLockStatus().equals("UNLOCK")))) {
        //if(3-3-09-03查询评价模板批次设置详情.使用锁定状态 不等于 未锁定)  35046

//异常结束 35047
      throw new BizException("B10000043","对不起，该批次已锁定，请稍后重试！",false);
      }
ImplementCommitTaskReportCheckComRespDto retData = new ImplementCommitTaskReportCheckComRespDto();





return retData;
  }
/**
   * D3-查朋友圈列表标准数据(公共)[6277]
   * gen by moon at 9/29/2024, 3:29:59 PM
   */
  @Trace(operationName = "D3-查朋友圈列表标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryHighMidBaseStandardDataByStageDataDetailComRespDto queryHighMidBaseStandardDataByStageDataDetailCom(QueryHighMidBaseStandardDataByStageDataDetailComReqDto reqDto){


      ImplementAccessParameterBizFieldRespDto receptionServiceRes_1 =null;
//virtualUsage D4-查询通过周期阶段资料过滤后标准数据列表(公共)  73056
QueryFiltrationStandardDataByStageDataListComRespDto queryFiltrationStandardDataByStageDataListComRespDto = null;
    QueryFiltrationStandardDataByStageDataListComReqDto queryFiltrationStandardDataByStageDataListComReqDto=new QueryFiltrationStandardDataByStageDataListComReqDto();
if(reqDto!=null){
      queryFiltrationStandardDataByStageDataListComReqDto.setCycleStageDataList(reqDto.getCycleStageDataList());//list-field-assign//sourceId:826273_1_73056
queryFiltrationStandardDataByStageDataListComReqDto.setIsNewData(reqDto.getIsNewData());//SimpleFieldAssign//sourceId:857571_1_73056
queryFiltrationStandardDataByStageDataListComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:2012101_1_73056
queryFiltrationStandardDataByStageDataListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:826770_1_73056
    }

    /*D4-查询通过周期阶段资料过滤后标准数据列表(公共)[4543]   */
    Assert.isNull(queryFiltrationStandardDataByStageDataListComReqDto.getIsNewData(),"D3-查朋友圈列表标准数据(公共)-D4-查询通过周期阶段资料过滤后标准数据列表(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryFiltrationStandardDataByStageDataListComReqDto.getExtendedField3(),"D3-查朋友圈列表标准数据(公共)-D4-查询通过周期阶段资料过滤后标准数据列表(公共)-扩展字段3不能为空",false);
Assert.isNull(queryFiltrationStandardDataByStageDataListComReqDto.getThemeContentId(),"D3-查朋友圈列表标准数据(公共)-D4-查询通过周期阶段资料过滤后标准数据列表(公共)-主题内容ID不能为空",false);
      queryFiltrationStandardDataByStageDataListComRespDto = fwCalcStandardDataClient.queryFiltrationStandardDataByStageDataListCom(queryFiltrationStandardDataByStageDataListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage M3-约定出参：标准数据列表  73057
//ModelCode: receptionService
        ImplementAccessParameterBizFieldRespDto receptionServiceRes = null;
    if(queryFiltrationStandardDataByStageDataListComRespDto !=null){
          ImplementAccessParameterBizFieldReqDto receptionServiceReq=new ImplementAccessParameterBizFieldReqDto();
  if(queryFiltrationStandardDataByStageDataListComRespDto!= null&&  queryFiltrationStandardDataByStageDataListComRespDto.getStandardDataList() !=null&& !CollectionUtil.isEmpty(queryFiltrationStandardDataByStageDataListComRespDto.getStandardDataList())){
      receptionServiceReq.setStandardDataList(queryFiltrationStandardDataByStageDataListComRespDto.getStandardDataList().stream().map(item -> BeanUtil.toBean(item, StandardDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:826647_1_73057
    }

    /*M3-约定出参：标准数据列表[5797]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbStandardData.implementAccessParameterBizField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
QueryHighMidBaseStandardDataByStageDataDetailComRespDto retData = new QueryHighMidBaseStandardDataByStageDataDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setStandardDataList(receptionServiceRes_1.getStandardDataList().stream().map(item -> BeanUtil.toBean(item, StandardDataDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:826649_1
    }




return retData;
  }
/**
   * D3-执行提交标准数据准备(公共)[7023]
   * gen by moon at 3/13/2024, 5:22:01 AM
   */
  @Trace(operationName = "D3-执行提交标准数据准备(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementReadyForCommitStandardDataComRespDto implementReadyForCommitStandardDataCom(ImplementReadyForCommitStandardDataComReqDto reqDto){


      QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto_1 =null;
ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto_1 =null;
QueryTargetContentAndExtendInfoDetailComRespDto queryTargetContentAndExtendInfoDetailComRespDto_1 =null;
AnalysisCurStandardDataCalcCycleModelComRespDto analysisCurStandardDataCalcCycleModelComRespDto_1 =null;
ImplementAnalyseWorkCycleUpdateSliceComRespDto implementAnalyseWorkCycleUpdateSliceComRespDto_1 =null;
ImplementIsWorkCycleDataAnalysisComRespDto implementIsWorkCycleDataAnalysisComRespDto_1 =null;
ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto_1 =null;
//步骤0: M3-计算接收上文字段（特殊方法） - calculateAcceptAboveFields
     //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:995962_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:995963_1
receptionServiceReq.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514136_1
receptionServiceReq.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1212380_1
receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:995978_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:996079_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:995960_1
    }

    /*M3-接收入参字段[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-执行提交标准数据准备(公共)-M3-接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3-执行提交标准数据准备(公共)-M3-接收入参字段-周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3-执行提交标准数据准备(公共)-M3-接收入参字段-关联目标内容类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3-执行提交标准数据准备(公共)-M3-接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbStandardData.calculateAcceptAboveFields(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1167905_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1167903_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1167904_1
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-执行提交标准数据准备(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-执行提交标准数据准备(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: D3-查询上一个执行周期的周期及目标周期详情(公共) - queryLastExecCycleAndTargetCycleDetailCom
     QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
    QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto=new QueryLastExecCycleAndTargetCycleDetailComReqDto();
  if(reqDto!=null){
      queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1167909_1
queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1167910_1
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1167911_1
    }

    /*D3-查询上一执行周期目标周期&周期ID[7507]   */
    Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3-执行提交标准数据准备(公共)-D3-查询上一执行周期目标周期&周期ID-被评对象目标周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(),"D3-执行提交标准数据准备(公共)-D3-查询上一执行周期目标周期&周期ID-周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-D3-查询上一执行周期目标周期&周期ID-冗余评价模板ID不能为空",false);
      queryLastExecCycleAndTargetCycleDetailComRespDto = executeCycleService.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;


      queryLastExecCycleAndTargetCycleDetailComRespDto_1 = queryLastExecCycleAndTargetCycleDetailComRespDto;

//步骤3: D3执行内容类型互转表类型(公共) - implementContentTypeChangeTableTypeCom
     ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:995973_1
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */

      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


      implementContentTypeChangeTableTypeComRespDto_1 = implementContentTypeChangeTableTypeComRespDto;

//步骤4: D3-查询目标内容及目标内容扩展信息（本级无实际值标识） - queryTargetContentAndExtendInfoDetailCom
     QueryTargetContentAndExtendInfoDetailComRespDto queryTargetContentAndExtendInfoDetailComRespDto = null;
    QueryTargetContentAndExtendInfoDetailComReqDto queryTargetContentAndExtendInfoDetailComReqDto=new QueryTargetContentAndExtendInfoDetailComReqDto();
  if(reqDto!=null){
      queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:996064_1
queryTargetContentAndExtendInfoDetailComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:996065_1
queryTargetContentAndExtendInfoDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:996066_1
    }

    /*D3-查目标内容一级目标分类[6148]   */
    Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentTypeCode(),"D3-执行提交标准数据准备(公共)-D3-查目标内容一级目标分类-关联目标内容类型编码不能为空",false);
Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getTargetCycleContentId(),"D3-执行提交标准数据准备(公共)-D3-查目标内容一级目标分类-关联目标内容ID不能为空",false);
Assert.isNull(queryTargetContentAndExtendInfoDetailComReqDto.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-D3-查目标内容一级目标分类-冗余评价模板ID不能为空",false);
      queryTargetContentAndExtendInfoDetailComRespDto = targetContentService.queryTargetContentAndExtendInfoDetailCom(queryTargetContentAndExtendInfoDetailComReqDto)/*vcase invoke isSameApp*/;


      queryTargetContentAndExtendInfoDetailComRespDto_1 = queryTargetContentAndExtendInfoDetailComRespDto;

//步骤5: 3-3-07查询执行周期阶段详情 - queryExecuteCycleStageDetail
     OmsExecuteCycleStage omsExecuteCycleStage = null;
    QueryExecuteCycleStageDetailReq queryExecuteCycleStageDetailReq=new QueryExecuteCycleStageDetailReq();
  queryExecuteCycleStageDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:996057_1
if(reqDto!=null){
      queryExecuteCycleStageDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:996055_1
queryExecuteCycleStageDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:996056_1
    }

    /*3-3-07查询执行周期阶段详情[2429]   */
    Assert.isNull(queryExecuteCycleStageDetailReq.getCycleId(),"D3-执行提交标准数据准备(公共)-3-3-07查询执行周期阶段详情-周期ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-3-3-07查询执行周期阶段详情-评价模板ID不能为空",false);
Assert.isNull(queryExecuteCycleStageDetailReq.getSubjectLifeCycle(),"D3-执行提交标准数据准备(公共)-3-3-07查询执行周期阶段详情-主体生命周期不能为空",false);
      omsExecuteCycleStage = mOmsExecuteCycleStageService.queryExecuteCycleStageDetail(queryExecuteCycleStageDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤6: D2-查询周期类型配置详情(公共) - queryCycleTypeConfDetailCom
     QueryCycleTypeConfDetailComRespDto queryCycleTypeConfDetailComRespDto = null;
    QueryCycleTypeConfDetailComReqDto queryCycleTypeConfDetailComReqDto=new QueryCycleTypeConfDetailComReqDto();
  if(reqDto!=null){
      queryCycleTypeConfDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1578562_1
    }

    /*D2-查询周期类型配置详情(公共)[8581]   */
    Assert.isNull(queryCycleTypeConfDetailComReqDto.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-D2-查询周期类型配置详情(公共)-冗余评价模板ID不能为空",false);
      queryCycleTypeConfDetailComRespDto = fwCompStandardDataClient.queryCycleTypeConfDetailCom(queryCycleTypeConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤7: D3分析目标归属周期计算周期五模型当前模型(公共) - analysisCurStandardDataCalcCycleModelCom
     AnalysisCurStandardDataCalcCycleModelComRespDto analysisCurStandardDataCalcCycleModelComRespDto = null;
    if(queryCycleTypeConfDetailComRespDto !=null){
          AnalysisCurStandardDataCalcCycleModelComReqDto analysisCurStandardDataCalcCycleModelComReqDto=new AnalysisCurStandardDataCalcCycleModelComReqDto();
  if(queryCycleTypeConfDetailComRespDto!=null){
      analysisCurStandardDataCalcCycleModelComReqDto.setPeriodicModeTypeCode(queryCycleTypeConfDetailComRespDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1577642_1
analysisCurStandardDataCalcCycleModelComReqDto.setSubcycleType(queryCycleTypeConfDetailComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1577634_1
analysisCurStandardDataCalcCycleModelComReqDto.setLastCycleType(queryCycleTypeConfDetailComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1577635_1
analysisCurStandardDataCalcCycleModelComReqDto.setSecondLastCycleType(queryCycleTypeConfDetailComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1577636_1
    }
if(reqDto!=null){
      analysisCurStandardDataCalcCycleModelComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1577631_1
analysisCurStandardDataCalcCycleModelComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1577637_1
    }
  if(omsExecuteCycleStage!=null){
      analysisCurStandardDataCalcCycleModelComReqDto.setUpdateCycleTypeCode(omsExecuteCycleStage.getCycleTypeCode());//SimpleFieldAssign//sourceId:1577632_1
analysisCurStandardDataCalcCycleModelComReqDto.setUpdateCycleEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:1577633_1
    }

    /*D3分析目标归属周期计算周期五模型当前模型(公共)[8574]   */
    Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getPeriodicModeTypeCode(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-周期模式类型编码不能为空",false);
Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getSubcycleType(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-子周期周期类型不能为空",false);
Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getLastCycleType(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-末级周期类型不能为空",false);
Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getEvaObjTargetCycleId(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getUpdateCycleTypeCode(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-更新周期类型标识不能为空",false);
Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getUpdateCycleEndTime(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-更新周期结束时间不能为空",false);
Assert.isNull(analysisCurStandardDataCalcCycleModelComReqDto.getEvaluationTemplateId(),"D3-执行提交标准数据准备(公共)-D3分析目标归属周期计算周期五模型当前模型(公共)-冗余评价模板ID不能为空",false);
      analysisCurStandardDataCalcCycleModelComRespDto = targetCalcService.analysisCurStandardDataCalcCycleModelCom(analysisCurStandardDataCalcCycleModelComReqDto)/*vcase invoke isSameApp*/;


      analysisCurStandardDataCalcCycleModelComRespDto_1 = analysisCurStandardDataCalcCycleModelComRespDto;
           }

//步骤8: D3-执行分析工作周期更新切片（公共） - implementAnalyseWorkCycleUpdateSliceCom
     ImplementAnalyseWorkCycleUpdateSliceComRespDto implementAnalyseWorkCycleUpdateSliceComRespDto = null;
    if(omsExecuteCycleStage !=null){
          ImplementAnalyseWorkCycleUpdateSliceComReqDto implementAnalyseWorkCycleUpdateSliceComReqDto=new ImplementAnalyseWorkCycleUpdateSliceComReqDto();
if(omsExecuteCycleStage!=null){
      implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleStartTime(omsExecuteCycleStage.getCycleStartTime());//SimpleFieldAssign//sourceId:996083_1
implementAnalyseWorkCycleUpdateSliceComReqDto.setCycleEndTime(omsExecuteCycleStage.getCycleEndTime());//SimpleFieldAssign//sourceId:996086_1
    }
if(reqDto!=null){
      implementAnalyseWorkCycleUpdateSliceComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:996084_1
    }

    /*D3-执行分析工作周期更新切片[6275]   */
Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleStartTime(),"D3-执行提交标准数据准备(公共)-D3-执行分析工作周期更新切片-目标计划开始时间不能为空",false);
Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getCycleEndTime(),"D3-执行提交标准数据准备(公共)-D3-执行分析工作周期更新切片-目标计划结束时间不能为空",false);
Assert.isNull(implementAnalyseWorkCycleUpdateSliceComReqDto.getEvaObjTargetCycleId(),"D3-执行提交标准数据准备(公共)-D3-执行分析工作周期更新切片-被评对象目标周期ID不能为空",false);
      implementAnalyseWorkCycleUpdateSliceComRespDto = cycleStageDataService.implementAnalyseWorkCycleUpdateSliceCom(implementAnalyseWorkCycleUpdateSliceComReqDto)/*vcase invoke isSameApp*/;


      implementAnalyseWorkCycleUpdateSliceComRespDto_1 = implementAnalyseWorkCycleUpdateSliceComRespDto;
           }

//步骤9: D3-执行分析是否工作周期数据(公共) - implementIsWorkCycleDataAnalysisCom
     ImplementIsWorkCycleDataAnalysisComRespDto implementIsWorkCycleDataAnalysisComRespDto = null;
    if(analysisCurStandardDataCalcCycleModelComRespDto !=null){
          ImplementIsWorkCycleDataAnalysisComReqDto implementIsWorkCycleDataAnalysisComReqDto=new ImplementIsWorkCycleDataAnalysisComReqDto();
  if(analysisCurStandardDataCalcCycleModelComRespDto!=null){
      implementIsWorkCycleDataAnalysisComReqDto.setStandardDataCalcCycleModel(analysisCurStandardDataCalcCycleModelComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1084863_1
    }

    /*D3-执行分析是否工作周期数据(公共)[7294]   */
    Assert.isNull(implementIsWorkCycleDataAnalysisComReqDto.getStandardDataCalcCycleModel(),"D3-执行提交标准数据准备(公共)-D3-执行分析是否工作周期数据(公共)-标准数据计算周期模型不能为空",false);
      implementIsWorkCycleDataAnalysisComRespDto = implementIsWorkCycleDataAnalysisCom(implementIsWorkCycleDataAnalysisComReqDto)/*vcase invoke 同服务,同domain*/;


      implementIsWorkCycleDataAnalysisComRespDto_1 = implementIsWorkCycleDataAnalysisComRespDto;
           }

//步骤10: D3准备相关人入参数据(公共) - implementStandardDataFillRoleInfoCom
     ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto = null;
    ImplementStandardDataFillRoleInfoComReqDto implementStandardDataFillRoleInfoComReqDto=new ImplementStandardDataFillRoleInfoComReqDto();
  implementStandardDataFillRoleInfoComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1514436_1
  if(reqDto!=null){
      implementStandardDataFillRoleInfoComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1514431_1
implementStandardDataFillRoleInfoComReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514430_1
implementStandardDataFillRoleInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514432_1
    }

    /*D3准备相关人入参数据(公共)[8371]   */
    Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getTargetCycleContentId(),"D3-执行提交标准数据准备(公共)-D3准备相关人入参数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getUseScene(),"D3-执行提交标准数据准备(公共)-D3准备相关人入参数据(公共)-虚拟组织使用场景不能为空",false);
      implementStandardDataFillRoleInfoComRespDto = virtualOrgService.implementStandardDataFillRoleInfoCom(implementStandardDataFillRoleInfoComReqDto)/*vcase invoke isSameApp*/;


      implementStandardDataFillRoleInfoComRespDto_1 = implementStandardDataFillRoleInfoComRespDto;

ImplementReadyForCommitStandardDataComRespDto retData = new ImplementReadyForCommitStandardDataComRespDto();
  if(queryLastExecCycleAndTargetCycleDetailComRespDto_1!=null){
      retData.setLastEvaObjTargetCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1167918_1
retData.setLastCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto_1.getLastCycleId());//SimpleFieldAssign//sourceId:1167919_1
    }
if(implementContentTypeChangeTableTypeComRespDto_1!=null){
      retData.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:996142_1
    }
if(queryTargetContentAndExtendInfoDetailComRespDto_1!=null){
      retData.setRootTargetCategoryId(queryTargetContentAndExtendInfoDetailComRespDto_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:996144_1
    }
if(implementAnalyseWorkCycleUpdateSliceComRespDto_1!=null){
      retData.setWorkCycleUpdateSlice(implementAnalyseWorkCycleUpdateSliceComRespDto_1.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:996145_1
    }
if(implementIsWorkCycleDataAnalysisComRespDto_1!=null){
      retData.setIsWorkCycleData(implementIsWorkCycleDataAnalysisComRespDto_1.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1084865_1
    }
if(analysisCurStandardDataCalcCycleModelComRespDto_1!=null){
      retData.setStandardDataCalcCycleModel(analysisCurStandardDataCalcCycleModelComRespDto_1.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1578711_1
    }
if(implementStandardDataFillRoleInfoComRespDto_1!=null){
      retData.setBizRoleObjId(implementStandardDataFillRoleInfoComRespDto_1.getRoleId());//SimpleFieldAssign//sourceId:1514947_1
retData.setBizRoleObjCode(implementStandardDataFillRoleInfoComRespDto_1.getRoleCode());//SimpleFieldAssign//sourceId:1514948_1
retData.setBizRoleObjName(implementStandardDataFillRoleInfoComRespDto_1.getRoleName());//SimpleFieldAssign//sourceId:1514949_1
retData.setVirtualOrgInductionRecordId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514946_1
retData.setVirtualOrgMemberId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgMemberId());//SimpleFieldAssign//sourceId:1557368_1
    }




return retData;
  }
/**
   * D3-执行分析是否工作周期数据(公共)[7294]
   * gen by moon at 7/10/2023, 1:49:05 AM
   */
  @Trace(operationName = "D3-执行分析是否工作周期数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementIsWorkCycleDataAnalysisComRespDto implementIsWorkCycleDataAnalysisCom(ImplementIsWorkCycleDataAnalysisComReqDto reqDto){


      CalculateAcceptAboveFieldsRespDto receptionServiceRes_5 =null;
//virtualUsage 约定：是  47431
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:1084855_1_47431

    /*约定：是[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-执行分析是否工作周期数据(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbStandardData.calculateAcceptAboveFields(receptionServiceReq);



//virtualUsage 约定：否  47432
      //ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_2 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_1=new CalculateAcceptAboveFieldsReqDto();
  receptionServiceReq_1.setTureOrFalse("FALSE");//sourceId:1084856_1_47432

    /*约定：否[6495]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3-执行分析是否工作周期数据(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_2 = nbStandardData.calculateAcceptAboveFields(receptionServiceReq_1);



if((reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("LAST_CYCLE")||reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("MID_OF_PROCESS_CYCLE"))) {
        //if((D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 末级周期 or D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 中间周期))  47430

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_4 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_2=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes_2!=null){
      receptionServiceReq_2.setIsWorkCycleData(receptionServiceRes_2.getTureOrFalse());//SimpleFieldAssign//sourceId:1084859_1_47433
    }

    /*约定出参：是否工作周期数据[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbStandardData.calculateAcceptAboveFields(receptionServiceReq_2);


      receptionServiceRes_5 = receptionServiceRes_4;
      }
else if((reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("SUB_CYCLE")||reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("MID_CYCLE")||reqDto!= null&&  reqDto.getStandardDataCalcCycleModel() !=null && reqDto.getStandardDataCalcCycleModel().equals("PARENT_CYCLE"))){
       //elseif((D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 子周期 or D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 中期 or D3-执行分析是否工作周期数据(公共).标准数据计算周期模型 等于 父周期))  47434

//ModelCode: receptionService
        CalculateAcceptAboveFieldsRespDto receptionServiceRes_6 = null;
    CalculateAcceptAboveFieldsReqDto receptionServiceReq_3=new CalculateAcceptAboveFieldsReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setIsWorkCycleData(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:1084859_1_47435
    }

    /*约定出参：是否工作周期数据[6495]  用于特殊方法接收上游入参。 */

      receptionServiceRes_6 = nbStandardData.calculateAcceptAboveFields(receptionServiceReq_3);


      receptionServiceRes_5 = receptionServiceRes_6;
    }
ImplementIsWorkCycleDataAnalysisComRespDto retData = new ImplementIsWorkCycleDataAnalysisComRespDto();
  if(receptionServiceRes_5!=null){
      retData.setIsWorkCycleData(receptionServiceRes_5.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1084862_1
    }




return retData;
  }
/**
   * D3执行增目标内容预算标准数据(公共)[7729]
   * gen by moon at 1/31/2024, 8:43:33 PM
   */
  @Trace(operationName = "D3执行增目标内容预算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAddTargetCycleBudgetStandardDataComRespDto implementAddTargetCycleBudgetStandardDataCom(ImplementAddTargetCycleBudgetStandardDataComReqDto reqDto){


      //virtualUsage D7-查当前内容资金账户详请（用于新增标准数据使用）  60389
      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1512646_1_60389
queryFinanceAccountDetailComReqDto.setIsArchive("FALSE");//sourceId:1512649_1_60389
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1512650_1_60389
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1512648_1_60389
    }

    /*D7-查当前内容资金账户详请（用于新增标准数据使用）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsArchive(),"D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-是否存档不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3执行增目标内容预算标准数据(公共)-D7-查当前内容资金账户详请（用于新增标准数据使用）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      //virtualUsage 3-3-09查当前内容目标子周期列表  52077
      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1247160_1_52077
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1247162_1_52077
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247158_1_52077
queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247159_1_52077
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247161_1_52077
    }

    /*3-3-09查当前内容目标子周期列表[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标子周期列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;



if((listOmsEvaluationObjectTargetCycle!= null&&  listOmsEvaluationObjectTargetCycle !=null && listOmsEvaluationObjectTargetCycle.size()>0)) {
        //if(3-3-09查当前内容目标子周期列表.被评对象目标周期列表数据集条数 大于 0)  52079

ImplementLoopAddTargetSubCycleBudgetDataComRespDto implementLoopAddTargetSubCycleBudgetDataComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 &&queryFinanceAccountDetailComRespDto !=null){
          ImplementLoopAddTargetSubCycleBudgetDataComReqDto implementLoopAddTargetSubCycleBudgetDataComReqDto=new ImplementLoopAddTargetSubCycleBudgetDataComReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      implementLoopAddTargetSubCycleBudgetDataComReqDto.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.integration.dto.EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1247093_1_52080
    }
if(queryFinanceAccountDetailComRespDto!=null){
      implementLoopAddTargetSubCycleBudgetDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513207_1_52080
    }
if(reqDto!=null){
      implementLoopAddTargetSubCycleBudgetDataComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247094_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setResultType(reqDto.getResultType());//SimpleFieldAssign//sourceId:1247096_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1247095_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247092_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1247097_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511485_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511486_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511487_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511488_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511489_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511490_1_52080
implementLoopAddTargetSubCycleBudgetDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511491_1_52080
    }

    /*D4执行循环增目标子周期预算标准数据(公共)[7717]   */
    Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getAccountId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-归属账户ID不能为空",false);
    Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getUnit(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getResultType(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementLoopAddTargetSubCycleBudgetDataComReqDto.getParentSubMidCycleType(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算标准数据(公共)-父子中周期类型不能为空",false);
      implementLoopAddTargetSubCycleBudgetDataComRespDto = fwCalcStandardDataClient.implementLoopAddTargetSubCycleBudgetDataCom(implementLoopAddTargetSubCycleBudgetDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
//virtualUsage D2执行资金来源数据集去重  52089
      ImplementManyFieldsDataSetDuplicateRemovalComRespDto implementManyFieldsDataSetDuplicateRemovalComRespDto = null;
    ImplementManyFieldsDataSetDuplicateRemovalComReqDto implementManyFieldsDataSetDuplicateRemovalComReqDto=new ImplementManyFieldsDataSetDuplicateRemovalComReqDto();
  if(reqDto!=null){
      //simpleList-to-objLists
    for (String item : reqDto.getEvaObjTargetCycleList()) {
                DataSetDuplicateRemovalDto oneItem = new DataSetDuplicateRemovalDto();
                if(reqDto!=null){
      oneItem.setCommPrimaryKey(item);//SimpleFieldAssign//sourceId:257088_2_52089
    }

                implementManyFieldsDataSetDuplicateRemovalComReqDto.getDataSetDuplicateRemovalList().add(oneItem);
            }//sourceId:1247509_1_52089
    }

    /*D2执行资金来源数据集去重[7323]   */

      implementManyFieldsDataSetDuplicateRemovalComRespDto = fwCompInterfaceModeClient.implementManyFieldsDataSetDuplicateRemovalCom(implementManyFieldsDataSetDuplicateRemovalComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage 3-3-09查当前内容目标父周期  52081
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1247337_1_52081
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1247339_1_52081
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247335_1_52081
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247336_1_52081
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247338_1_52081
    }

    /*3-3-09查当前内容目标父周期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标父周期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle != null )) {
        //if(3-3-09查当前内容目标父周期.出参 值不等于空 )  52082

ImplementAddTargetParentMidCycleBudgetDataComRespDto implementAddTargetParentMidCycleBudgetDataComRespDto = null;
    if(implementManyFieldsDataSetDuplicateRemovalComRespDto !=null&&queryFinanceAccountDetailComRespDto !=null&&omsEvaluationObjectTargetCycle !=null){
          ImplementAddTargetParentMidCycleBudgetDataComReqDto implementAddTargetParentMidCycleBudgetDataComReqDto=new ImplementAddTargetParentMidCycleBudgetDataComReqDto();
  implementAddTargetParentMidCycleBudgetDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1247107_1_52083
  implementAddTargetParentMidCycleBudgetDataComReqDto.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1247111_1_52083
if(implementManyFieldsDataSetDuplicateRemovalComRespDto!= null&&  implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() !=null&& !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())){
      implementAddTargetParentMidCycleBudgetDataComReqDto.setEvaObjTargetCycleList(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item->item.getCommPrimaryKey())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1247098_1_52083
    }
if(queryFinanceAccountDetailComRespDto!=null){
      implementAddTargetParentMidCycleBudgetDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513216_1_52083
    }
if(reqDto!=null){
      implementAddTargetParentMidCycleBudgetDataComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247106_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1247108_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1247110_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247112_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247099_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleMode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1247109_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511384_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setPersonLiableTypeCode(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511385_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511386_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511387_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511388_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511389_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511390_1_52083
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementAddTargetParentMidCycleBudgetDataComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1247100_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1247101_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1247102_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1247103_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleTypeCode(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1247104_1_52083
implementAddTargetParentMidCycleBudgetDataComReqDto.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1247105_1_52083
    }

    /*D4执行目标父周期预算标准数据(公共)[7724]   */
    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getAccountId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-归属账户ID不能为空",false);
    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getUnit(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getResultType(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getBelongToContentTypeCode(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getBelongToContentId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getEvaObjTargetCycleId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleStartTime(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleEndTime(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleTypeCode(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getCycleMode(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-周期模式不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto.getParentSubMidCycleType(),"D3执行增目标内容预算标准数据(公共)-D4执行目标父周期预算标准数据(公共)-父子中周期类型不能为空",false);
      implementAddTargetParentMidCycleBudgetDataComRespDto = fwCalcStandardDataClient.implementAddTargetParentMidCycleBudgetDataCom(implementAddTargetParentMidCycleBudgetDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE")&&reqDto!= null&&  reqDto.getOpenMidCycle() !=null && reqDto.getOpenMidCycle().equals("TRUE"))) {
        //if((D3执行增目标内容预算标准数据(公共).周期模式类型编码 等于 父子周期 and D3执行增目标内容预算标准数据(公共).是否开启中期 等于 是))  52092

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setIsMetaphase("TRUE");//sourceId:1247324_1_52093
queryEvaObjTargetCycleDetailReq_1.setIsArchive("FALSE");//sourceId:1247326_1_52093
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247322_1_52093
queryEvaObjTargetCycleDetailReq_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247323_1_52093
queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247325_1_52093
    }

    /*3-3-09查当前内容目标中期[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjEntityId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTargetCycleContentId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsMetaphase(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-是否中期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsArchive(),"D3执行增目标内容预算标准数据(公共)-3-3-09查当前内容目标中期-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle_2 != null )) {
        //if(3-3-09查当前内容目标中期.出参 值不等于空 )  52094

ImplementAddTargetParentMidCycleBudgetDataComRespDto implementAddTargetParentMidCycleBudgetDataComRespDto_1 = null;
    if(implementManyFieldsDataSetDuplicateRemovalComRespDto !=null&&queryFinanceAccountDetailComRespDto !=null&&omsEvaluationObjectTargetCycle_2 !=null){
          ImplementAddTargetParentMidCycleBudgetDataComReqDto implementAddTargetParentMidCycleBudgetDataComReqDto_1=new ImplementAddTargetParentMidCycleBudgetDataComReqDto();
  implementAddTargetParentMidCycleBudgetDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1247122_1_52097
  implementAddTargetParentMidCycleBudgetDataComReqDto_1.setParentSubMidCycleType("MID_CYCLE");//sourceId:1247126_1_52097
if(implementManyFieldsDataSetDuplicateRemovalComRespDto!= null&&  implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList() !=null&& !CollectionUtil.isEmpty(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList())){
      implementAddTargetParentMidCycleBudgetDataComReqDto_1.setEvaObjTargetCycleList(implementManyFieldsDataSetDuplicateRemovalComRespDto.getDataSetDuplicateRemovalList().stream().map(item->item.getCommPrimaryKey())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1247113_1_52097
    }
if(queryFinanceAccountDetailComRespDto!=null){
      implementAddTargetParentMidCycleBudgetDataComReqDto_1.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513239_1_52097
    }
if(reqDto!=null){
      implementAddTargetParentMidCycleBudgetDataComReqDto_1.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247121_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1247123_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1247125_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247127_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247114_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleMode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1247124_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511416_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511417_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511418_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511419_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511420_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511421_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511422_1_52097
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      implementAddTargetParentMidCycleBudgetDataComReqDto_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_2.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1247115_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleId(omsEvaluationObjectTargetCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1247116_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleStartTime(omsEvaluationObjectTargetCycle_2.getCycleStartTime());//SimpleFieldAssign//sourceId:1247117_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleEndTime(omsEvaluationObjectTargetCycle_2.getCycleEndTime());//SimpleFieldAssign//sourceId:1247118_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleTypeCode(omsEvaluationObjectTargetCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1247119_1_52097
implementAddTargetParentMidCycleBudgetDataComReqDto_1.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1247120_1_52097
    }

    /*D4执行目标中周期预算标准数据(公共)[7724]   */
    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getAccountId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-归属账户ID不能为空",false);
    Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getUnit(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getResultType(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getBelongToContentTypeCode(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getBelongToContentId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getEvaObjTargetCycleId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleStartTime(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleEndTime(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleTypeCode(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getParentSubMidCycleType(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAddTargetParentMidCycleBudgetDataComReqDto_1.getCycleMode(),"D3执行增目标内容预算标准数据(公共)-D4执行目标中周期预算标准数据(公共)-周期模式不能为空",false);
      implementAddTargetParentMidCycleBudgetDataComRespDto_1 = fwCalcStandardDataClient.implementAddTargetParentMidCycleBudgetDataCom(implementAddTargetParentMidCycleBudgetDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
      }
//virtualUsage D4执行循环增目标子周期预算占比标准数据(公共)  54639
      ImplementLoopAddSubCycleBudgetPropStandardDataComRespDto implementLoopAddSubCycleBudgetPropStandardDataComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 &&queryFinanceAccountDetailComRespDto !=null&&omsEvaluationObjectTargetCycle !=null){
          ImplementLoopAddSubCycleBudgetPropStandardDataComReqDto implementLoopAddSubCycleBudgetPropStandardDataComReqDto=new ImplementLoopAddSubCycleBudgetPropStandardDataComReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setEvaObjTargetCycleList(listOmsEvaluationObjectTargetCycle.stream().map(item -> BeanUtil.toBean(item, com.wicket.okrcalc.integration.dto.EvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1354048_1_54639
    }
if(queryFinanceAccountDetailComRespDto!=null){
      implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1513222_1_54639
    }
if(reqDto!=null){
      implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1354053_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1354054_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1354050_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setCalcStartTime(reqDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1354051_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511445_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511446_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511447_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511448_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511449_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511450_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511451_1_54639
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1354049_1_54639
implementLoopAddSubCycleBudgetPropStandardDataComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1354052_1_54639
    }

    /*D4执行循环增目标子周期预算占比标准数据(公共)[8024]   */
    Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getAccountId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-归属账户ID不能为空",false);
    Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getBelongToContentTypeCode(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getBelongToContentId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getEvaObjTargetCycleId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-内容目标父周期ID不能为空",false);
Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getCycleId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-父周期ID不能为空",false);
Assert.isNull(implementLoopAddSubCycleBudgetPropStandardDataComReqDto.getEvaluationTemplateId(),"D3执行增目标内容预算标准数据(公共)-D4执行循环增目标子周期预算占比标准数据(公共)-冗余评价模板ID不能为空",false);
      implementLoopAddSubCycleBudgetPropStandardDataComRespDto = fwCalcStandardDataClient.implementLoopAddSubCycleBudgetPropStandardDataCom(implementLoopAddSubCycleBudgetPropStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



      }
ImplementAddTargetCycleBudgetStandardDataComRespDto retData = new ImplementAddTargetCycleBudgetStandardDataComRespDto();





return retData;
  }
/**
   * D3执行循环增祖先预算标准数据(公共)[7731]
   * gen by moon at 1/31/2024, 8:45:17 PM
   */
  @Trace(operationName = "D3执行循环增祖先预算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopAddAncestorBudgetStandardDataComRespDto implementLoopAddAncestorBudgetStandardDataCom(ImplementLoopAddAncestorBudgetStandardDataComReqDto reqDto){


      QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto_1 =null;
      //virtualUsage D3查祖先目标周期列表(公共)  52101
      QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto = null;
    QueryAncestorTargetCycleListComReqDto queryAncestorTargetCycleListComReqDto=new QueryAncestorTargetCycleListComReqDto();
  queryAncestorTargetCycleListComReqDto.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1247796_1_52101
queryAncestorTargetCycleListComReqDto.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1247797_1_52101
if(reqDto!=null){
      queryAncestorTargetCycleListComReqDto.setComCode(reqDto.getCurrentContentCode());//SimpleFieldAssign//sourceId:1247795_1_52101
queryAncestorTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247798_1_52101
    }

    /*D3查祖先目标周期列表(公共)[6312]   */
    Assert.isNull(queryAncestorTargetCycleListComReqDto.getComCode(),"D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-通用编码标识不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjEntityId(),"D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjTypeCode(),"D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaluationTemplateId(),"D3执行循环增祖先预算标准数据(公共)-D3查祖先目标周期列表(公共)-冗余评价模板ID不能为空",false);
      queryAncestorTargetCycleListComRespDto = targetContentService.queryAncestorTargetCycleListCom(queryAncestorTargetCycleListComReqDto)/*vcase invoke isSameApp*/;


      queryAncestorTargetCycleListComRespDto_1 = queryAncestorTargetCycleListComRespDto;
if(((new ArrayList<>()).size()>0)) {
        //if(D3查祖先目标周期列表(公共).被评对象目标周期列表数据集条数 大于 0)  52100

//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryAncestorTargetCycleListComRespDto.getEvaObjTargetCycleList()){

ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(circulationCollectionsRes!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1247860_1_52106
    }

    /*D3内容类型转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3执行循环增祖先预算标准数据(公共)-D3内容类型转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;



ImplementAddTargetCycleBudgetStandardDataComRespDto implementAddTargetCycleBudgetStandardDataComRespDto = null;
    if(implementContentTypeChangeTableTypeComRespDto !=null){
          ImplementAddTargetCycleBudgetStandardDataComReqDto implementAddTargetCycleBudgetStandardDataComReqDto=new ImplementAddTargetCycleBudgetStandardDataComReqDto();
  implementAddTargetCycleBudgetStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1247837_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setCalcStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1247838_1_52104
if(reqDto!=null){
      implementAddTargetCycleBudgetStandardDataComReqDto.setEvaObjTargetCycleList(reqDto.getEvaObjTargetCycleList());//list-field-assign//sourceId:1247839_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247830_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1247831_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1247832_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setOpenMidCycle(reqDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1247834_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1247833_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1511518_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1511519_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1511520_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1511521_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1511522_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1511523_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1511524_1_52104
    }
if(circulationCollectionsRes!=null){
      implementAddTargetCycleBudgetStandardDataComReqDto.setEvaObjEntityId(circulationCollectionsRes.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1247836_1_52104
implementAddTargetCycleBudgetStandardDataComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247835_1_52104
    }
if(implementContentTypeChangeTableTypeComRespDto!=null){
      implementAddTargetCycleBudgetStandardDataComReqDto.setBelongToContentTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1247840_1_52104
    }

    /*D3执行增目标内容预算标准数据(公共)[7729]   */
    Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getEvaObjEntityId(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getTargetCycleContentId(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getEvaluationTemplateId(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getPeriodicModeTypeCode(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getParentSubMidCycleType(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getOpenMidCycle(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-是否开启中期不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getBelongToContentTypeCode(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getUnit(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getResultType(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(implementAddTargetCycleBudgetStandardDataComReqDto.getCalcStartTime(),"D3执行循环增祖先预算标准数据(公共)-D3执行增目标内容预算标准数据(公共)-计算开始时间不能为空",false);
      implementAddTargetCycleBudgetStandardDataComRespDto = implementAddTargetCycleBudgetStandardDataCom(implementAddTargetCycleBudgetStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementLoopAddAncestorBudgetStandardDataComRespDto retData = new ImplementLoopAddAncestorBudgetStandardDataComRespDto();
  if(queryAncestorTargetCycleListComRespDto_1!=null){
      retData.setLookAncestorNodeList(queryAncestorTargetCycleListComRespDto_1.getEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, LookAncestorNodeDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1513848_1
    }




return retData;
  }
/**
   * D3-更新当前及祖先预算标准数据(公共)[7690]
   * gen by moon at 1/31/2024, 8:41:47 PM
   */
  @Trace(operationName = "D3-更新当前及祖先预算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshParentBudgetStandardDataComRespDto refreshParentBudgetStandardDataCom(RefreshParentBudgetStandardDataComReqDto reqDto){


      //virtualUsage D3-执行当前内容预算标准数据(公共)  52022
      ImplementCurBudgetStandardDataComRespDto implementCurBudgetStandardDataComRespDto = null;
    ImplementCurBudgetStandardDataComReqDto implementCurBudgetStandardDataComReqDto=new ImplementCurBudgetStandardDataComReqDto();
  if(reqDto!=null){
      implementCurBudgetStandardDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1244785_1_52022
implementCurBudgetStandardDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244786_1_52022
implementCurBudgetStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1244779_1_52022
implementCurBudgetStandardDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1244783_1_52022
implementCurBudgetStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244780_1_52022
implementCurBudgetStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1244781_1_52022
implementCurBudgetStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244782_1_52022
implementCurBudgetStandardDataComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1514983_1_52022
implementCurBudgetStandardDataComReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514982_1_52022
    }

    /*D3-执行当前内容预算标准数据(公共)[7714]   */
    Assert.isNull(implementCurBudgetStandardDataComReqDto.getTargetCycleContentId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto.getTargetCycleContentTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto.getCycleId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-周期ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto.getUpdateCycleId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto.getEvaluationTemplateId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-冗余评价模板ID不能为空",false);
      implementCurBudgetStandardDataComRespDto = implementCurBudgetStandardDataCom(implementCurBudgetStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;



//virtualUsage M3-执行财务账户【循环开始】  51998
      //ModelCode: circulationCollections
        for (FinanceAccountDto circulationCollectionsRes: reqDto.getFinanceAccountList()){

//virtualUsage 3-3-09查被评对象目标周期详情  52025
      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1244969_1_52025
if(queryEvaObjTargetCycleDetailReq!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1244963_1_52025
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1244964_1_52025
queryEvaObjTargetCycleDetailReq.setTreeTypeCode("PLAN_TREE");//sourceId:1244965_1_52025
    }
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1244967_1_52025
queryEvaObjTargetCycleDetailReq.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244966_1_52025
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1245072_1_52025
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244968_1_52025
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTreeTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-关联目标内容类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-更新当前及祖先预算标准数据(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//virtualUsage 3-3-11查周期阶段资料详情  52026
      OmsTspeCycleStageData omsTspeCycleStageData = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryCycleStageDataDetailReq queryCycleStageDataDetailReq=new QueryCycleStageDataDetailReq();
  queryCycleStageDataDetailReq.setCycleDataObjTypeCode("EVA_OBJ_TARGET_CYCLE");//sourceId:1245080_1_52026
queryCycleStageDataDetailReq.setStageContentType("STA_WOR_SUM_CON");//sourceId:1245078_1_52026
queryCycleStageDataDetailReq.setCycleDataTypeCode("CYC_STA_DAT");//sourceId:1245079_1_52026
if(reqDto!=null){
      queryCycleStageDataDetailReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1245077_1_52026
queryCycleStageDataDetailReq.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1245082_1_52026
    }
if(omsEvaluationObjectTargetCycle!=null){
      queryCycleStageDataDetailReq.setCycleDataObjId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1245081_1_52026
    }

    /*3-3-11查周期阶段资料详情[2771]   */
    Assert.isNull(queryCycleStageDataDetailReq.getCycleId(),"D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjId(),"D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期资料归属对象ID不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataObjTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期资料归属对象类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getStageContentType(),"D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-内容性质类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getCycleDataTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-周期阶段资料类型编码不能为空",false);
Assert.isNull(queryCycleStageDataDetailReq.getThemeContentId(),"D3-更新当前及祖先预算标准数据(公共)-3-3-11查周期阶段资料详情-主题内容ID不能为空",false);
      omsTspeCycleStageData = mOmsTspeCycleStageDataService.queryCycleStageDataDetail(queryCycleStageDataDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
//virtualUsage D3-执行当前内容预算标准数据(公共)  52023
      ImplementCurBudgetStandardDataComRespDto implementCurBudgetStandardDataComRespDto_1 = null;
    if(omsEvaluationObjectTargetCycle !=null&&omsTspeCycleStageData !=null){
          ImplementCurBudgetStandardDataComReqDto implementCurBudgetStandardDataComReqDto_1=new ImplementCurBudgetStandardDataComReqDto();
  if(circulationCollectionsRes!=null){
      implementCurBudgetStandardDataComReqDto_1.setTargetCycleContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1244785_1_52023
implementCurBudgetStandardDataComReqDto_1.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244786_1_52023
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementCurBudgetStandardDataComReqDto_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1244779_1_52023
    }
if(omsTspeCycleStageData!=null){
      implementCurBudgetStandardDataComReqDto_1.setCycleStageDataId(omsTspeCycleStageData.getCycleStageDataId());//SimpleFieldAssign//sourceId:1244783_1_52023
    }
if(reqDto!=null){
      implementCurBudgetStandardDataComReqDto_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244780_1_52023
implementCurBudgetStandardDataComReqDto_1.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1244781_1_52023
implementCurBudgetStandardDataComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244782_1_52023
implementCurBudgetStandardDataComReqDto_1.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1514983_1_52023
implementCurBudgetStandardDataComReqDto_1.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514982_1_52023
    }

    /*D3-执行当前内容预算标准数据(公共)[7714]   */
    Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getTargetCycleContentId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getTargetCycleContentTypeCode(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getEvaObjTargetCycleId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getCycleId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-周期ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getUpdateCycleId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementCurBudgetStandardDataComReqDto_1.getEvaluationTemplateId(),"D3-更新当前及祖先预算标准数据(公共)-D3-执行当前内容预算标准数据(公共)-冗余评价模板ID不能为空",false);
      implementCurBudgetStandardDataComRespDto_1 = implementCurBudgetStandardDataCom(implementCurBudgetStandardDataComReqDto_1)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage M3-执行【循环结束】  52000
      //ModelCode: circulationEnd
        }

RefreshParentBudgetStandardDataComRespDto retData = new RefreshParentBudgetStandardDataComRespDto();





return retData;
  }
/**
   * D3-执行当前内容预算标准数据(公共)[7714]
   * gen by moon at 2/1/2024, 1:13:16 AM
   */
  @Trace(operationName = "D3-执行当前内容预算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementCurBudgetStandardDataComRespDto implementCurBudgetStandardDataCom(ImplementCurBudgetStandardDataComReqDto reqDto){


      //virtualUsage 约定：数据类型编码  52024
      //ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq.setBudgetTotalType("BUDGET_TOTAL");//CUSTOM_CONVENTION//sourceId:1244811_1_52024
  receptionServiceReq.setBudgetAmountType("BUDGET_AMOUNT");//CUSTOM_CONVENTION//sourceId:1244807_1_52024
receptionServiceReq.setBudgetUsableType("BUDGET_USABLE");//CUSTOM_CONVENTION//sourceId:1244808_1_52024
receptionServiceReq.setBudgetFrozenType("BUDGET_FROZEN");//CUSTOM_CONVENTION//sourceId:1244809_1_52024
receptionServiceReq.setCumulativeBudgetType("CUMULATIVE_BUDGET");//CUSTOM_CONVENTION//sourceId:1244810_1_52024
receptionServiceReq.setFundsReceivedTotalType("FUNDS_RECEIVED_TOTAL");//CUSTOM_CONVENTION//sourceId:1244816_1_52024
receptionServiceReq.setFundsReceivedBalanceType("FUNDS_RECEIVED_BALANCE");//CUSTOM_CONVENTION//sourceId:1244812_1_52024
receptionServiceReq.setFundsReceivedUsableType("FUNDS_RECEIVED_USABLE");//CUSTOM_CONVENTION//sourceId:1244814_1_52024
receptionServiceReq.setFundsReceivedFrozenType("FUNDS_RECEIVED_FROZEN");//CUSTOM_CONVENTION//sourceId:1244815_1_52024
receptionServiceReq.setCumulativeFundsReceivedType("CUMULATIVE_FUNDS_RECEIVED");//CUSTOM_CONVENTION//sourceId:1244813_1_52024

    /*约定：数据类型编码[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBudgetTotalType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算账户累计总金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getBudgetAmountType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算账户余额类型不能为空",false);
Assert.isNull(receptionServiceReq.getBudgetUsableType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算可用金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getBudgetFrozenType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-预算冻结金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getCumulativeBudgetType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-累计结算金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getFundsReceivedTotalType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户累计到账总金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getFundsReceivedBalanceType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户余额类型不能为空",false);
Assert.isNull(receptionServiceReq.getFundsReceivedUsableType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户可用金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getFundsReceivedFrozenType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-实体账户冻结金额类型不能为空",false);
Assert.isNull(receptionServiceReq.getCumulativeFundsReceivedType(),"D3-执行当前内容预算标准数据(公共)-约定：数据类型编码-累计使用金额类型不能为空",false);
      receptionServiceRes = nbStandardData.implementAcceptFieldByStandardData(receptionServiceReq);



//virtualUsage D4-1查标准数据详情(公共)  52019
      QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1244594_1_52019
queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1244595_1_52019
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1244593_1_52019
queryStandardDataDetailComReqDto.setPeriodId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244592_1_52019
queryStandardDataDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1244610_1_52019
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1244596_1_52019
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-更新周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-数据使用场景编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-数据类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D7-查预算账户详情(公共)  52001
      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1244081_1_52001
queryFinanceAccountDetailComReqDto.setIsArchive("FALSE");//sourceId:1244083_1_52001
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1244084_1_52001
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1244082_1_52001
    }

    /*D7-查预算账户详情(公共)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsArchive(),"D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-是否存档不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3-执行当前内容预算标准数据(公共)-D7-查预算账户详情(公共)-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//virtualUsage D3-执行提交标准数据准备(公共)  60393
      ImplementReadyForCommitStandardDataComRespDto implementReadyForCommitStandardDataComRespDto = null;
    if(queryStandardDataDetailComRespDto !=null){
          ImplementReadyForCommitStandardDataComReqDto implementReadyForCommitStandardDataComReqDto=new ImplementReadyForCommitStandardDataComReqDto();
  if(reqDto!=null){
      implementReadyForCommitStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513245_1_60393
implementReadyForCommitStandardDataComReqDto.setRoleCode(reqDto.getRoleCode());//SimpleFieldAssign//sourceId:1513257_1_60393
implementReadyForCommitStandardDataComReqDto.setIsPersonCharge(reqDto.getIsPersonCharge());//SimpleFieldAssign//sourceId:1514453_1_60393
implementReadyForCommitStandardDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1513247_1_60393
implementReadyForCommitStandardDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513248_1_60393
implementReadyForCommitStandardDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513244_1_60393
    }
if(queryStandardDataDetailComRespDto!=null){
      implementReadyForCommitStandardDataComReqDto.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513246_1_60393
    }

    /*D3-执行提交标准数据准备(公共)[7023]   */
    Assert.isNull(implementReadyForCommitStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementReadyForCommitStandardDataComReqDto.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-周期ID不能为空",false);
Assert.isNull(implementReadyForCommitStandardDataComReqDto.getTargetCycleContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementReadyForCommitStandardDataComReqDto.getTargetCycleContentId(),"D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementReadyForCommitStandardDataComReqDto.getEvaluationTemplateId(),"D3-执行当前内容预算标准数据(公共)-D3-执行提交标准数据准备(公共)-冗余评价模板ID不能为空",false);
      implementReadyForCommitStandardDataComRespDto = implementReadyForCommitStandardDataCom(implementReadyForCommitStandardDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((queryFinanceAccountDetailComRespDto!= null&& queryFinanceAccountDetailComRespDto.getAccountId() != null )) {
        //if(D7-查预算账户详情(公共).账户ID 值不等于空 )  60340

CommitStandardDataComRespDto commitStandardDataComRespDto = null;
    if(queryFinanceAccountDetailComRespDto !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60403
commitStandardDataComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60403
commitStandardDataComReqDto.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60403
commitStandardDataComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60403
commitStandardDataComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60403
commitStandardDataComReqDto.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60403
commitStandardDataComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60403
commitStandardDataComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60403
if(queryFinanceAccountDetailComRespDto!=null){
      commitStandardDataComReqDto.setDataResult(queryFinanceAccountDetailComRespDto.getAccountActualBalance());//SimpleFieldAssign//sourceId:1513813_1_60403
commitStandardDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60403
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60403
commitStandardDataComReqDto.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60403
commitStandardDataComReqDto.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60403
commitStandardDataComReqDto.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60403
commitStandardDataComReqDto.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60403
commitStandardDataComReqDto.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60403
commitStandardDataComReqDto.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1515218_1_60403
commitStandardDataComReqDto.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1515219_1_60403
commitStandardDataComReqDto.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60403
commitStandardDataComReqDto.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60403
commitStandardDataComReqDto.setPersonLiableObjId(queryStandardDataDetailComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1513825_1_60403
commitStandardDataComReqDto.setBizRoleObjId(queryStandardDataDetailComRespDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1513827_1_60403
commitStandardDataComReqDto.setBizRoleObjCode(queryStandardDataDetailComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1513829_1_60403
commitStandardDataComReqDto.setBizRoleObjName(queryStandardDataDetailComRespDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1513828_1_60403
commitStandardDataComReqDto.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60403
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60403
//commitStandardDataComReqDto.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60403
commitStandardDataComReqDto.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60403
//commitStandardDataComReqDto.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60403
commitStandardDataComReqDto.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60403
commitStandardDataComReqDto.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60403
commitStandardDataComReqDto.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60403
commitStandardDataComReqDto.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60403
commitStandardDataComReqDto.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60403
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto.setDataType(receptionServiceRes.getBudgetAmountType());//SimpleFieldAssign//sourceId:1513815_1_60403
    }
if(reqDto!=null){
//      commitStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60403
//commitStandardDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60403
commitStandardDataComReqDto.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60403
commitStandardDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60403
    }

    /*D4-1提交标准数据(用于预算账户)[5640]   */
    Assert.isNull(commitStandardDataComReqDto.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空",false);
      commitStandardDataComRespDto = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_1 = null;
    if(queryFinanceAccountDetailComRespDto !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_1=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60406
commitStandardDataComReqDto_1.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60406
commitStandardDataComReqDto_1.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60406
commitStandardDataComReqDto_1.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60406
commitStandardDataComReqDto_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60406
commitStandardDataComReqDto_1.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60406
commitStandardDataComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60406
commitStandardDataComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60406
if(queryFinanceAccountDetailComRespDto!=null){
      commitStandardDataComReqDto_1.setDataResult(queryFinanceAccountDetailComRespDto.getSettlableBalance());//SimpleFieldAssign//sourceId:1513813_1_60406
commitStandardDataComReqDto_1.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60406
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_1.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60406
commitStandardDataComReqDto_1.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60406
commitStandardDataComReqDto_1.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60406
commitStandardDataComReqDto_1.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60406
commitStandardDataComReqDto_1.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60406
commitStandardDataComReqDto_1.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60406
commitStandardDataComReqDto_1.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60406
commitStandardDataComReqDto_1.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60406
commitStandardDataComReqDto_1.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60406
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_1.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60406
//commitStandardDataComReqDto_1.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60406
commitStandardDataComReqDto_1.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60406
//commitStandardDataComReqDto_1.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60406
commitStandardDataComReqDto_1.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60406
commitStandardDataComReqDto_1.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60406
commitStandardDataComReqDto_1.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60406
commitStandardDataComReqDto_1.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1513827_1_60406
commitStandardDataComReqDto_1.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1513829_1_60406
commitStandardDataComReqDto_1.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1513828_1_60406
commitStandardDataComReqDto_1.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60406
commitStandardDataComReqDto_1.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60406
commitStandardDataComReqDto_1.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60406
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_1.setDataType(receptionServiceRes.getBudgetUsableType());//SimpleFieldAssign//sourceId:1513815_1_60406
    }
if(reqDto!=null){
//      commitStandardDataComReqDto_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60406
//commitStandardDataComReqDto_1.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60406
commitStandardDataComReqDto_1.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60406
commitStandardDataComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60406
    }

    /*D4-1提交标准数据(用于预算账户)[5640]   */
    Assert.isNull(commitStandardDataComReqDto_1.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto_1.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_1.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空",false);
      commitStandardDataComRespDto_1 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_2 = null;
    if(queryFinanceAccountDetailComRespDto !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_2=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_2.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60413
commitStandardDataComReqDto_2.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60413
commitStandardDataComReqDto_2.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60413
commitStandardDataComReqDto_2.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60413
commitStandardDataComReqDto_2.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60413
commitStandardDataComReqDto_2.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60413
commitStandardDataComReqDto_2.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60413
commitStandardDataComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60413
if(queryFinanceAccountDetailComRespDto!=null){
      commitStandardDataComReqDto_2.setDataResult(queryFinanceAccountDetailComRespDto.getUnSettlableBalance());//SimpleFieldAssign//sourceId:1513813_1_60413
commitStandardDataComReqDto_2.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60413
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_2.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60413
commitStandardDataComReqDto_2.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60413
commitStandardDataComReqDto_2.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60413
commitStandardDataComReqDto_2.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60413
commitStandardDataComReqDto_2.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60413
commitStandardDataComReqDto_2.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60413
commitStandardDataComReqDto_2.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60413
commitStandardDataComReqDto_2.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60413
commitStandardDataComReqDto_2.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60413
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_2.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60413
//commitStandardDataComReqDto_2.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60413
commitStandardDataComReqDto_2.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60413
//commitStandardDataComReqDto_2.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60413
commitStandardDataComReqDto_2.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60413
commitStandardDataComReqDto_2.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60413
commitStandardDataComReqDto_2.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60413
commitStandardDataComReqDto_2.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1513827_1_60413
commitStandardDataComReqDto_2.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1513829_1_60413
commitStandardDataComReqDto_2.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1513828_1_60413
commitStandardDataComReqDto_2.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60413
commitStandardDataComReqDto_2.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60413
commitStandardDataComReqDto_2.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60413
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_2.setDataType(receptionServiceRes.getBudgetFrozenType());//SimpleFieldAssign//sourceId:1513815_1_60413
    }
if(reqDto!=null){
//      commitStandardDataComReqDto_2.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60413
//commitStandardDataComReqDto_2.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60413
commitStandardDataComReqDto_2.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60413
commitStandardDataComReqDto_2.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60413
    }

    /*D4-1提交标准数据(用于预算账户)[5640]   */
    Assert.isNull(commitStandardDataComReqDto_2.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto_2.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_2.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空",false);
      commitStandardDataComRespDto_2 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_3 = null;
    if(queryFinanceAccountDetailComRespDto !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_3=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_3.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60414
commitStandardDataComReqDto_3.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60414
commitStandardDataComReqDto_3.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60414
commitStandardDataComReqDto_3.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60414
commitStandardDataComReqDto_3.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60414
commitStandardDataComReqDto_3.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60414
commitStandardDataComReqDto_3.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60414
commitStandardDataComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60414
if(queryFinanceAccountDetailComRespDto!=null){
      commitStandardDataComReqDto_3.setDataResult(queryFinanceAccountDetailComRespDto.getAccruedSettledAmount());//SimpleFieldAssign//sourceId:1513813_1_60414
commitStandardDataComReqDto_3.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60414
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_3.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60414
commitStandardDataComReqDto_3.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60414
commitStandardDataComReqDto_3.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60414
commitStandardDataComReqDto_3.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60414
commitStandardDataComReqDto_3.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60414
commitStandardDataComReqDto_3.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60414
commitStandardDataComReqDto_3.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60414
commitStandardDataComReqDto_3.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60414
commitStandardDataComReqDto_3.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60414
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_3.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60414
//commitStandardDataComReqDto_3.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60414
commitStandardDataComReqDto_3.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60414
//commitStandardDataComReqDto_3.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60414
commitStandardDataComReqDto_3.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60414
commitStandardDataComReqDto_3.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60414
commitStandardDataComReqDto_3.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60414
commitStandardDataComReqDto_3.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1513827_1_60414
commitStandardDataComReqDto_3.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1513829_1_60414
commitStandardDataComReqDto_3.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1513828_1_60414
commitStandardDataComReqDto_3.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60414
commitStandardDataComReqDto_3.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60414
commitStandardDataComReqDto_3.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60414
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_3.setDataType(receptionServiceRes.getCumulativeBudgetType());//SimpleFieldAssign//sourceId:1513815_1_60414
    }
if(reqDto!=null){
//      commitStandardDataComReqDto_3.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60414
//commitStandardDataComReqDto_3.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60414
commitStandardDataComReqDto_3.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60414
commitStandardDataComReqDto_3.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60414
    }

    /*D4-1提交标准数据(用于预算账户)[5640]   */
    Assert.isNull(commitStandardDataComReqDto_3.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto_3.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_3.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空",false);
      commitStandardDataComRespDto_3 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_4 = null;
    if(queryFinanceAccountDetailComRespDto !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_4=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_4.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1513816_1_60415
commitStandardDataComReqDto_4.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1513826_1_60415
commitStandardDataComReqDto_4.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1513844_1_60415
commitStandardDataComReqDto_4.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1513843_1_60415
commitStandardDataComReqDto_4.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1513810_1_60415
commitStandardDataComReqDto_4.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1513811_1_60415
commitStandardDataComReqDto_4.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1513833_1_60415
commitStandardDataComReqDto_4.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1513830_1_60415
if(queryFinanceAccountDetailComRespDto!=null){
      commitStandardDataComReqDto_4.setDataResult(queryFinanceAccountDetailComRespDto.getTotalBudgetAmount());//SimpleFieldAssign//sourceId:1513813_1_60415
commitStandardDataComReqDto_4.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514424_1_60415
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_4.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1513814_1_60415
commitStandardDataComReqDto_4.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1513835_1_60415
commitStandardDataComReqDto_4.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1513840_1_60415
commitStandardDataComReqDto_4.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1513841_1_60415
commitStandardDataComReqDto_4.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1513837_1_60415
commitStandardDataComReqDto_4.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1513820_1_60415
commitStandardDataComReqDto_4.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1513823_1_60415
commitStandardDataComReqDto_4.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1513824_1_60415
commitStandardDataComReqDto_4.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1513846_1_60415
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_4.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513817_1_60415
//commitStandardDataComReqDto_4.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1513818_1_60415
commitStandardDataComReqDto_4.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1513842_1_60415
//commitStandardDataComReqDto_4.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1513819_1_60415
commitStandardDataComReqDto_4.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1513839_1_60415
commitStandardDataComReqDto_4.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1513838_1_60415
commitStandardDataComReqDto_4.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513825_1_60415
commitStandardDataComReqDto_4.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1513827_1_60415
commitStandardDataComReqDto_4.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1513829_1_60415
commitStandardDataComReqDto_4.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1513828_1_60415
commitStandardDataComReqDto_4.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1513845_1_60415
commitStandardDataComReqDto_4.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1513831_1_60415
commitStandardDataComReqDto_4.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1513836_1_60415
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_4.setDataType(receptionServiceRes.getBudgetTotalType());//SimpleFieldAssign//sourceId:1513815_1_60415
    }
if(reqDto!=null){
//      commitStandardDataComReqDto_4.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513809_1_60415
//commitStandardDataComReqDto_4.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513812_1_60415
commitStandardDataComReqDto_4.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513832_1_60415
commitStandardDataComReqDto_4.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513834_1_60415
    }

    /*D4-1提交标准数据(用于预算账户)[5640]   */
    Assert.isNull(commitStandardDataComReqDto_4.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-归属内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto_4.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主题内容ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_4.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于预算账户)-主体生命周期不能为空",false);
      commitStandardDataComRespDto_4 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;



           }
           }
//virtualUsage D7-查实体账户详情(公共)  52007
      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_2 = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto_1=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto_1.setIsBudgetAccount("FALSE");//sourceId:1244114_1_52007
queryFinanceAccountDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1244116_1_52007
queryFinanceAccountDetailComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1244117_1_52007
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto_1.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1244115_1_52007
    }

    /*D7-查实体账户详情(公共)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountObjectId(),"D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsBudgetAccount(),"D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsArchive(),"D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-是否存档不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getSpaceId(),"D3-执行当前内容预算标准数据(公共)-D7-查实体账户详情(公共)-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto_2 = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryFinanceAccountDetailComRespDto_2!= null&& queryFinanceAccountDetailComRespDto_2.getAccountId() != null )) {
        //if(D7-查实体账户详情(公共).账户ID 值不等于空 )  60352

CommitStandardDataComRespDto commitStandardDataComRespDto_5 = null;
    if(queryFinanceAccountDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_5=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_5.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60419
commitStandardDataComReqDto_5.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60419
commitStandardDataComReqDto_5.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60419
commitStandardDataComReqDto_5.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60419
commitStandardDataComReqDto_5.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60419
commitStandardDataComReqDto_5.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60419
commitStandardDataComReqDto_5.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60419
commitStandardDataComReqDto_5.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60419
if(reqDto!=null){
//      commitStandardDataComReqDto_5.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60419
//commitStandardDataComReqDto_5.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60419
commitStandardDataComReqDto_5.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60419
commitStandardDataComReqDto_5.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60419
    }
if(queryFinanceAccountDetailComRespDto_2!=null){
      commitStandardDataComReqDto_5.setDataResult(queryFinanceAccountDetailComRespDto_2.getAccountActualBalance());//SimpleFieldAssign//sourceId:1514101_1_60419
commitStandardDataComReqDto_5.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60419
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_5.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60419
commitStandardDataComReqDto_5.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60419
commitStandardDataComReqDto_5.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60419
commitStandardDataComReqDto_5.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60419
commitStandardDataComReqDto_5.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60419
commitStandardDataComReqDto_5.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60419
commitStandardDataComReqDto_5.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60419
commitStandardDataComReqDto_5.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60419
commitStandardDataComReqDto_5.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60419
commitStandardDataComReqDto_5.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60419
commitStandardDataComReqDto_5.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60419
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_5.setDataType(receptionServiceRes.getFundsReceivedBalanceType());//SimpleFieldAssign//sourceId:1514103_1_60419
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_5.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60419
//commitStandardDataComReqDto_5.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60419
commitStandardDataComReqDto_5.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60419
//commitStandardDataComReqDto_5.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60419
commitStandardDataComReqDto_5.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60419
commitStandardDataComReqDto_5.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60419
commitStandardDataComReqDto_5.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60419
commitStandardDataComReqDto_5.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1514115_1_60419
commitStandardDataComReqDto_5.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1514117_1_60419
commitStandardDataComReqDto_5.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1514116_1_60419
commitStandardDataComReqDto_5.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60419
commitStandardDataComReqDto_5.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60419
commitStandardDataComReqDto_5.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60419
    }

    /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_5.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getUnit(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getDataUsageSceneCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getUpdateCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getWorkCycleUpdateSlice(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getParentSubMidCycleType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getIsWorkCycleData(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBelongToPersonalIdentityId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_5.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空",false);
      commitStandardDataComRespDto_5 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_6 = null;
    if(queryFinanceAccountDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_6=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_6.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60420
commitStandardDataComReqDto_6.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60420
commitStandardDataComReqDto_6.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60420
commitStandardDataComReqDto_6.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60420
commitStandardDataComReqDto_6.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60420
commitStandardDataComReqDto_6.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60420
commitStandardDataComReqDto_6.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60420
commitStandardDataComReqDto_6.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60420
if(reqDto!=null){
//      commitStandardDataComReqDto_6.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60420
//commitStandardDataComReqDto_6.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60420
commitStandardDataComReqDto_6.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60420
commitStandardDataComReqDto_6.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60420
    }
if(queryFinanceAccountDetailComRespDto_2!=null){
      commitStandardDataComReqDto_6.setDataResult(queryFinanceAccountDetailComRespDto_2.getSettlableBalance());//SimpleFieldAssign//sourceId:1514101_1_60420
commitStandardDataComReqDto_6.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60420
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_6.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60420
commitStandardDataComReqDto_6.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60420
commitStandardDataComReqDto_6.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60420
commitStandardDataComReqDto_6.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60420
commitStandardDataComReqDto_6.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60420
commitStandardDataComReqDto_6.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60420
commitStandardDataComReqDto_6.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60420
commitStandardDataComReqDto_6.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60420
commitStandardDataComReqDto_6.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60420
commitStandardDataComReqDto_6.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60420
commitStandardDataComReqDto_6.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60420
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_6.setDataType(receptionServiceRes.getFundsReceivedUsableType());//SimpleFieldAssign//sourceId:1514103_1_60420
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_6.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60420
//commitStandardDataComReqDto_6.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60420
commitStandardDataComReqDto_6.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60420
//commitStandardDataComReqDto_6.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60420
commitStandardDataComReqDto_6.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60420
commitStandardDataComReqDto_6.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60420
commitStandardDataComReqDto_6.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60420
commitStandardDataComReqDto_6.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1514115_1_60420
commitStandardDataComReqDto_6.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1514117_1_60420
commitStandardDataComReqDto_6.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1514116_1_60420
commitStandardDataComReqDto_6.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60420
commitStandardDataComReqDto_6.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60420
commitStandardDataComReqDto_6.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60420
    }

    /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_6.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getUnit(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getDataUsageSceneCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getUpdateCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getWorkCycleUpdateSlice(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getParentSubMidCycleType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getIsWorkCycleData(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBelongToPersonalIdentityId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_6.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空",false);
      commitStandardDataComRespDto_6 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_6).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_7 = null;
    if(queryFinanceAccountDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_7=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_7.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60421
commitStandardDataComReqDto_7.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60421
commitStandardDataComReqDto_7.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60421
commitStandardDataComReqDto_7.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60421
commitStandardDataComReqDto_7.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60421
commitStandardDataComReqDto_7.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60421
commitStandardDataComReqDto_7.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60421
commitStandardDataComReqDto_7.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60421
if(reqDto!=null){
//      commitStandardDataComReqDto_7.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60421
//commitStandardDataComReqDto_7.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60421
commitStandardDataComReqDto_7.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60421
commitStandardDataComReqDto_7.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60421
    }
if(queryFinanceAccountDetailComRespDto_2!=null){
      commitStandardDataComReqDto_7.setDataResult(queryFinanceAccountDetailComRespDto_2.getUnSettlableBalance());//SimpleFieldAssign//sourceId:1514101_1_60421
commitStandardDataComReqDto_7.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60421
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_7.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60421
commitStandardDataComReqDto_7.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60421
commitStandardDataComReqDto_7.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60421
commitStandardDataComReqDto_7.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60421
commitStandardDataComReqDto_7.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60421
commitStandardDataComReqDto_7.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60421
commitStandardDataComReqDto_7.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60421
commitStandardDataComReqDto_7.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60421
commitStandardDataComReqDto_7.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60421
commitStandardDataComReqDto_7.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60421
commitStandardDataComReqDto_7.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60421
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_7.setDataType(receptionServiceRes.getFundsReceivedFrozenType());//SimpleFieldAssign//sourceId:1514103_1_60421
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_7.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60421
//commitStandardDataComReqDto_7.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60421
commitStandardDataComReqDto_7.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60421
//commitStandardDataComReqDto_7.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60421
commitStandardDataComReqDto_7.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60421
commitStandardDataComReqDto_7.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60421
commitStandardDataComReqDto_7.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60421
commitStandardDataComReqDto_7.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1514115_1_60421
commitStandardDataComReqDto_7.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1514117_1_60421
commitStandardDataComReqDto_7.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1514116_1_60421
commitStandardDataComReqDto_7.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60421
commitStandardDataComReqDto_7.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60421
commitStandardDataComReqDto_7.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60421
    }

    /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_7.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getUnit(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getDataUsageSceneCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getUpdateCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getWorkCycleUpdateSlice(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getParentSubMidCycleType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getIsWorkCycleData(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBelongToPersonalIdentityId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_7.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空",false);
      commitStandardDataComRespDto_7 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_7).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_8 = null;
    if(queryFinanceAccountDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_8=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_8.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60422
commitStandardDataComReqDto_8.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60422
commitStandardDataComReqDto_8.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60422
commitStandardDataComReqDto_8.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60422
commitStandardDataComReqDto_8.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60422
commitStandardDataComReqDto_8.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60422
commitStandardDataComReqDto_8.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60422
commitStandardDataComReqDto_8.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60422
if(reqDto!=null){
//      commitStandardDataComReqDto_8.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60422
//commitStandardDataComReqDto_8.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60422
commitStandardDataComReqDto_8.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60422
commitStandardDataComReqDto_8.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60422
    }
if(queryFinanceAccountDetailComRespDto_2!=null){
      commitStandardDataComReqDto_8.setDataResult(queryFinanceAccountDetailComRespDto_2.getAccruedSettledAmount());//SimpleFieldAssign//sourceId:1514101_1_60422
commitStandardDataComReqDto_8.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60422
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_8.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60422
commitStandardDataComReqDto_8.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60422
commitStandardDataComReqDto_8.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60422
commitStandardDataComReqDto_8.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60422
commitStandardDataComReqDto_8.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60422
commitStandardDataComReqDto_8.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60422
commitStandardDataComReqDto_8.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60422
commitStandardDataComReqDto_8.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60422
commitStandardDataComReqDto_8.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60422
commitStandardDataComReqDto_8.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60422
commitStandardDataComReqDto_8.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60422
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_8.setDataType(receptionServiceRes.getCumulativeFundsReceivedType());//SimpleFieldAssign//sourceId:1514103_1_60422
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_8.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60422
//commitStandardDataComReqDto_8.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60422
commitStandardDataComReqDto_8.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60422
//commitStandardDataComReqDto_8.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60422
commitStandardDataComReqDto_8.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60422
commitStandardDataComReqDto_8.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60422
commitStandardDataComReqDto_8.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60422
commitStandardDataComReqDto_8.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1514115_1_60422
commitStandardDataComReqDto_8.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1514117_1_60422
commitStandardDataComReqDto_8.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1514116_1_60422
commitStandardDataComReqDto_8.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60422
commitStandardDataComReqDto_8.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60422
commitStandardDataComReqDto_8.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60422
    }

    /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_8.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getUnit(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getDataUsageSceneCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getUpdateCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getWorkCycleUpdateSlice(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getParentSubMidCycleType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getIsWorkCycleData(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBelongToPersonalIdentityId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_8.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空",false);
      commitStandardDataComRespDto_8 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_8).getData()/*vcase invoke 跨dubbo调用;*/;



           }
CommitStandardDataComRespDto commitStandardDataComRespDto_9 = null;
    if(queryFinanceAccountDetailComRespDto_2 !=null&&queryStandardDataDetailComRespDto !=null&&implementReadyForCommitStandardDataComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto_9=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto_9.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514098_1_60423
commitStandardDataComReqDto_9.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514099_1_60423
commitStandardDataComReqDto_9.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1514104_1_60423
commitStandardDataComReqDto_9.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514131_1_60423
commitStandardDataComReqDto_9.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514114_1_60423
commitStandardDataComReqDto_9.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514132_1_60423
commitStandardDataComReqDto_9.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514118_1_60423
commitStandardDataComReqDto_9.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514121_1_60423
if(reqDto!=null){
//      commitStandardDataComReqDto_9.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514097_1_60423
//commitStandardDataComReqDto_9.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514100_1_60423
commitStandardDataComReqDto_9.setBelongToContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514120_1_60423
commitStandardDataComReqDto_9.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514122_1_60423
    }
if(queryFinanceAccountDetailComRespDto_2!=null){
      commitStandardDataComReqDto_9.setDataResult(queryFinanceAccountDetailComRespDto_2.getTotalBudgetAmount());//SimpleFieldAssign//sourceId:1514101_1_60423
commitStandardDataComReqDto_9.setAccountId(queryFinanceAccountDetailComRespDto_2.getAccountId());//SimpleFieldAssign//sourceId:1514452_1_60423
    }
if(queryStandardDataDetailComRespDto!=null){
      commitStandardDataComReqDto_9.setUnit(queryStandardDataDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1514102_1_60423
commitStandardDataComReqDto_9.setCycleId(queryStandardDataDetailComRespDto.getPeriodId());//SimpleFieldAssign//sourceId:1514108_1_60423
commitStandardDataComReqDto_9.setCycleStartTime(queryStandardDataDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1514109_1_60423
commitStandardDataComReqDto_9.setCycleEndTime(queryStandardDataDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1514110_1_60423
commitStandardDataComReqDto_9.setCycleTypeCode(queryStandardDataDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514111_1_60423
commitStandardDataComReqDto_9.setCycleTypeInstanceCode(queryStandardDataDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514112_1_60423
commitStandardDataComReqDto_9.setUpdateCycleId(queryStandardDataDetailComRespDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514123_1_60423
commitStandardDataComReqDto_9.setUpdateCycleStartTime(queryStandardDataDetailComRespDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514128_1_60423
commitStandardDataComReqDto_9.setUpdateCycleEndTime(queryStandardDataDetailComRespDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514129_1_60423
commitStandardDataComReqDto_9.setUpdateCycleTypeCode(queryStandardDataDetailComRespDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514125_1_60423
commitStandardDataComReqDto_9.setExtendedField3(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1514134_1_60423
    }
if(receptionServiceRes!=null){
      commitStandardDataComReqDto_9.setDataType(receptionServiceRes.getFundsReceivedTotalType());//SimpleFieldAssign//sourceId:1514103_1_60423
    }
if(implementReadyForCommitStandardDataComRespDto!=null){
//      commitStandardDataComReqDto_9.setLastEvaObjTargetCycleId(implementReadyForCommitStandardDataComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514105_1_60423
//commitStandardDataComReqDto_9.setLastCycleId(implementReadyForCommitStandardDataComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514106_1_60423
commitStandardDataComReqDto_9.setWorkCycleUpdateSlice(implementReadyForCommitStandardDataComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514126_1_60423
//commitStandardDataComReqDto_9.setParentSubMidCycleType(implementReadyForCommitStandardDataComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514107_1_60423
commitStandardDataComReqDto_9.setStandardDataCalcCycleModel(implementReadyForCommitStandardDataComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514127_1_60423
commitStandardDataComReqDto_9.setIsWorkCycleData(implementReadyForCommitStandardDataComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514130_1_60423
commitStandardDataComReqDto_9.setPersonLiableObjId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514113_1_60423
commitStandardDataComReqDto_9.setBizRoleObjId(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjId()):"");//SimpleFieldAssign//sourceId:1514115_1_60423
commitStandardDataComReqDto_9.setBizRoleObjCode(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjCode()):"");//SimpleFieldAssign//sourceId:1514117_1_60423
commitStandardDataComReqDto_9.setBizRoleObjName(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()!=null?String.valueOf(implementReadyForCommitStandardDataComRespDto.getBizRoleObjName()):"");//SimpleFieldAssign//sourceId:1514116_1_60423
commitStandardDataComReqDto_9.setBelongToPersonalIdentityId(implementReadyForCommitStandardDataComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1514133_1_60423
commitStandardDataComReqDto_9.setBelongToContentTypeCode(implementReadyForCommitStandardDataComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1514119_1_60423
commitStandardDataComReqDto_9.setRootTargetCategoryId(implementReadyForCommitStandardDataComRespDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514124_1_60423
    }

    /*D4-1提交标准数据(用于实体账户)[5640]   */
//    Assert.isNull(commitStandardDataComReqDto_9.getEvaObjTargetCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getTableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getDataResult(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getUnit(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-冗余单位不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getDataType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getResultType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getDataUsageSceneCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据使用场景编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-目标计划结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleStartTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleEndTime(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getUpdateCycleTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-更新周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getWorkCycleUpdateSlice(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-工作周期更新切片不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getParentSubMidCycleType(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-父子中周期类型不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getIsWorkCycleData(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-是否工作周期数据不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getPersonLiableObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getPersonLiableTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBizRoleObjId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBizRoleObjCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBizRoleObjName(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBelongToPersonalIdentityTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBelongToPersonalIdentityId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属个人ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBelongToContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getBelongToContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getSubjectLifeCycle(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主体生命周期不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getThemeContentTypeCode(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto_9.getThemeContentId(),"D3-执行当前内容预算标准数据(公共)-D4-1提交标准数据(用于实体账户)-主题内容ID不能为空",false);
      commitStandardDataComRespDto_9 = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto_9).getData()/*vcase invoke 跨dubbo调用;*/;



           }
           }
ImplementCurBudgetStandardDataComRespDto retData = new ImplementCurBudgetStandardDataComRespDto();





return retData;
  }
/**
   * D3-执行自动汇报标准数据准备(公共)[8304]
   * gen by moon at 1/18/2024, 4:40:53 PM
   */
  @Trace(operationName = "D3-执行自动汇报标准数据准备(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAutoReportStandardDataComRespDto implementAutoReportStandardDataCom(ImplementAutoReportStandardDataComReqDto reqDto){


      JudgeAutoReportVerifyProgressAndActualValueComRespDto judgeAutoReportVerifyProgressAndActualValueComRespDto_1 =null;
//virtualUsage 约定：进度值/实际值数据类型编码  59754
      //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PROGRESS_VALUE");//CUSTOM_CONVENTION//sourceId:1489624_1_59754
receptionServiceReq.setCustomField2("ACTUAL_VALUE");//CUSTOM_CONVENTION//sourceId:1489625_1_59754

    /*约定：进度值/实际值数据类型编码[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3-执行自动汇报标准数据准备(公共)-约定：进度值/实际值数据类型编码-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3-执行自动汇报标准数据准备(公共)-约定：进度值/实际值数据类型编码-自定义字段2不能为空",false);
      receptionServiceRes = nbStandardData.implementFourthReceivingField(receptionServiceReq);



//virtualUsage D3-判断自动汇报校验进度值与实际值(公共)  59601
      JudgeAutoReportVerifyProgressAndActualValueComRespDto judgeAutoReportVerifyProgressAndActualValueComRespDto = null;
    JudgeAutoReportVerifyProgressAndActualValueComReqDto judgeAutoReportVerifyProgressAndActualValueComReqDto=new JudgeAutoReportVerifyProgressAndActualValueComReqDto();
  if(reqDto!=null){
      judgeAutoReportVerifyProgressAndActualValueComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1486512_1_59601
judgeAutoReportVerifyProgressAndActualValueComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1486513_1_59601
judgeAutoReportVerifyProgressAndActualValueComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1486514_1_59601
judgeAutoReportVerifyProgressAndActualValueComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1486515_1_59601
judgeAutoReportVerifyProgressAndActualValueComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1486516_1_59601
judgeAutoReportVerifyProgressAndActualValueComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1486517_1_59601
    }

    /*D3-判断自动汇报校验进度值与实际值(公共)[8299]   */
    Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getEvaObjTargetCycleId(),"D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getCycleId(),"D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-周期ID不能为空",false);
Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getTargetCycleContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getTargetCycleContentId(),"D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-关联目标内容ID不能为空",false);
Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getTargetId(),"D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-冗余目标ID不能为空",false);
Assert.isNull(judgeAutoReportVerifyProgressAndActualValueComReqDto.getEvaluationTemplateId(),"D3-执行自动汇报标准数据准备(公共)-D3-判断自动汇报校验进度值与实际值(公共)-冗余评价模板ID不能为空",false);
      judgeAutoReportVerifyProgressAndActualValueComRespDto = taskService.judgeAutoReportVerifyProgressAndActualValueCom(judgeAutoReportVerifyProgressAndActualValueComReqDto)/*vcase invoke isSameApp*/;


      judgeAutoReportVerifyProgressAndActualValueComRespDto_1 = judgeAutoReportVerifyProgressAndActualValueComRespDto;
//virtualUsage D3-查询上一个执行周期的周期及目标周期详情(公共)  59744
      QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
    QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto=new QueryLastExecCycleAndTargetCycleDetailComReqDto();
  if(reqDto!=null){
      queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1489206_1_59744
queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489207_1_59744
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1489208_1_59744
    }

    /*D3-查询上一个执行周期的周期及目标周期详情(公共)[7507]   */
    Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3-执行自动汇报标准数据准备(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(),"D3-执行自动汇报标准数据准备(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3-执行自动汇报标准数据准备(公共)-D3-查询上一个执行周期的周期及目标周期详情(公共)-冗余评价模板ID不能为空",false);
      queryLastExecCycleAndTargetCycleDetailComRespDto = executeCycleService.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;



if((judgeAutoReportVerifyProgressAndActualValueComRespDto!= null&&  judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateProgressStandardData() !=null && judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateProgressStandardData().equals("CREATE_PROGRESS_VALUE"))) {
        //if(D3-判断自动汇报校验进度值与实际值(公共).是否新增进度值标准数据 等于 新增进度值)  59604

QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    if(queryLastExecCycleAndTargetCycleDetailComRespDto !=null&&judgeAutoReportVerifyProgressAndActualValueComRespDto !=null){
          QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:1489652_1_59751
queryStandardDataDetailComReqDto.setIsUpdateCycleNewData("TRUE");//sourceId:1489666_1_59751
queryStandardDataDetailComReqDto.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1489667_1_59751
queryStandardDataDetailComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1489642_1_59751
queryStandardDataDetailComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1489659_1_59751
queryStandardDataDetailComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1489646_1_59751
queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1489647_1_59751
if(receptionServiceRes!=null){
      queryStandardDataDetailComReqDto.setDataType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1489645_1_59751
    }
if(queryLastExecCycleAndTargetCycleDetailComRespDto!=null){
      queryStandardDataDetailComReqDto.setPeriodId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1489654_1_59751
queryStandardDataDetailComReqDto.setEntityId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1489643_1_59751
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1489660_1_59751
    }
if(judgeAutoReportVerifyProgressAndActualValueComRespDto!=null){
      queryStandardDataDetailComReqDto.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489655_1_59751
queryStandardDataDetailComReqDto.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489656_1_59751
queryStandardDataDetailComReqDto.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489693_1_59751
queryStandardDataDetailComReqDto.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489663_1_59751
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsUpdateCycleNewData(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否更新周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据使用场景编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getTableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getPersonLiableObjId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getBizRoleObjCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getPersonLiableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getBelongToPersonalIdentityId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据归属个人ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getParentSubMidCycleType(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
RefreshAutoReportStandardDataComRespDto refreshAutoReportStandardDataComRespDto = null;
    if(judgeAutoReportVerifyProgressAndActualValueComRespDto !=null&&queryStandardDataDetailComRespDto !=null){
          RefreshAutoReportStandardDataComReqDto refreshAutoReportStandardDataComReqDto=new RefreshAutoReportStandardDataComReqDto();
  refreshAutoReportStandardDataComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1489096_1_59741
if(receptionServiceRes!=null){
      refreshAutoReportStandardDataComReqDto.setDataType(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1489080_1_59741
    }
if(judgeAutoReportVerifyProgressAndActualValueComRespDto!=null){
      refreshAutoReportStandardDataComReqDto.setDataResult(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1489081_1_59741
refreshAutoReportStandardDataComReqDto.setUnit(judgeAutoReportVerifyProgressAndActualValueComRespDto.getUnit());//SimpleFieldAssign//sourceId:1489082_1_59741
refreshAutoReportStandardDataComReqDto.setUpdateCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489086_1_59741
refreshAutoReportStandardDataComReqDto.setUpdateCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489087_1_59741
refreshAutoReportStandardDataComReqDto.setUpdateCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489088_1_59741
refreshAutoReportStandardDataComReqDto.setCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489090_1_59741
refreshAutoReportStandardDataComReqDto.setCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489091_1_59741
refreshAutoReportStandardDataComReqDto.setCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489092_1_59741
refreshAutoReportStandardDataComReqDto.setCycleTypeInstanceCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1489093_1_59741
refreshAutoReportStandardDataComReqDto.setIsWorkCycleData(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1489094_1_59741
refreshAutoReportStandardDataComReqDto.setWorkCycleUpdateSlice(judgeAutoReportVerifyProgressAndActualValueComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1489095_1_59741
refreshAutoReportStandardDataComReqDto.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489097_1_59741
refreshAutoReportStandardDataComReqDto.setStandardDataCalcCycleModel(judgeAutoReportVerifyProgressAndActualValueComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1489098_1_59741
refreshAutoReportStandardDataComReqDto.setIsSystemDocking(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsSystemDocking());//SimpleFieldAssign//sourceId:1489099_1_59741
refreshAutoReportStandardDataComReqDto.setDataUsageSceneCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1489100_1_59741
refreshAutoReportStandardDataComReqDto.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489101_1_59741
refreshAutoReportStandardDataComReqDto.setPersonLiableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1489104_1_59741
refreshAutoReportStandardDataComReqDto.setBizRoleObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1489102_1_59741
refreshAutoReportStandardDataComReqDto.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489105_1_59741
refreshAutoReportStandardDataComReqDto.setBizRoleObjName(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1489103_1_59741
refreshAutoReportStandardDataComReqDto.setBelongToPersonalIdentityTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1489115_1_59741
refreshAutoReportStandardDataComReqDto.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489116_1_59741
refreshAutoReportStandardDataComReqDto.setTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1489108_1_59741
refreshAutoReportStandardDataComReqDto.setEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1489113_1_59741
refreshAutoReportStandardDataComReqDto.setBelongToContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1489110_1_59741
refreshAutoReportStandardDataComReqDto.setBelongToContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1489111_1_59741
refreshAutoReportStandardDataComReqDto.setCategoryContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCategoryContentTypeCode());//SimpleFieldAssign//sourceId:1489118_1_59741
refreshAutoReportStandardDataComReqDto.setTopTargetCategoryID(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTopTargetCategoryID());//SimpleFieldAssign//sourceId:1489119_1_59741
refreshAutoReportStandardDataComReqDto.setThemeContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1489106_1_59741
refreshAutoReportStandardDataComReqDto.setThemeContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentId());//SimpleFieldAssign//sourceId:1489107_1_59741
refreshAutoReportStandardDataComReqDto.setFromContentTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1489109_1_59741
refreshAutoReportStandardDataComReqDto.setFromContentEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1489114_1_59741
    }
if(queryStandardDataDetailComRespDto!=null){
      refreshAutoReportStandardDataComReqDto.setParentDataResultId(queryStandardDataDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1489083_1_59741
refreshAutoReportStandardDataComReqDto.setParentDataResult(queryStandardDataDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1489084_1_59741
    }
if(reqDto!=null){
      refreshAutoReportStandardDataComReqDto.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489085_1_59741
refreshAutoReportStandardDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489089_1_59741
    }

    /*D4-更新自动汇报更新标准数据(公共)[8305]   */
    Assert.isNull(refreshAutoReportStandardDataComReqDto.getDataType(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getDataResult(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getUnit(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleStartTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleEndTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getUpdateCycleTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleStartTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleEndTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getCycleTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getIsWorkCycleData(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getWorkCycleUpdateSlice(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-工作周期更新切片不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getParentSubMidCycleType(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getStandardDataCalcCycleModel(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-标准数据计算周期模型不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getIsSystemDocking(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否系统对接不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getResultType(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getDataUsageSceneCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据使用场景编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getPersonLiableObjId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getPersonLiableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBizRoleObjId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBizRoleObjCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBizRoleObjName(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToPersonalIdentityId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getTableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getEntityId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getBelongToContentId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getCategoryContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-目标分类类型表类型不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getTopTargetCategoryID(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-一级目标分类ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getThemeContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto.getThemeContentId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容ID不能为空",false);
      refreshAutoReportStandardDataComRespDto = fwCalcStandardDataClient.refreshAutoReportStandardDataCom(refreshAutoReportStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
if((judgeAutoReportVerifyProgressAndActualValueComRespDto!= null&&  judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateActualStandardData() !=null && judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsCreateActualStandardData().equals("CREATE_ACTUAL_VALUE"))) {
        //if(D3-判断自动汇报校验进度值与实际值(公共).是否新增实际值标准数据 等于 新增实际值)  59606

QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_2 = null;
    if(queryLastExecCycleAndTargetCycleDetailComRespDto !=null&&judgeAutoReportVerifyProgressAndActualValueComRespDto !=null){
          QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto_1=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto_1.setIsNewData("TRUE");//sourceId:1489652_1_59752
queryStandardDataDetailComReqDto_1.setIsUpdateCycleNewData("TRUE");//sourceId:1489666_1_59752
queryStandardDataDetailComReqDto_1.setDataUsageSceneCode("TARGET_PLAN_CALC_DATA_STATISTICS");//sourceId:1489667_1_59752
queryStandardDataDetailComReqDto_1.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1489642_1_59752
queryStandardDataDetailComReqDto_1.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1489659_1_59752
queryStandardDataDetailComReqDto_1.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1489646_1_59752
queryStandardDataDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1489647_1_59752
if(receptionServiceRes!=null){
      queryStandardDataDetailComReqDto_1.setDataType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1489645_1_59752
    }
if(queryLastExecCycleAndTargetCycleDetailComRespDto!=null){
      queryStandardDataDetailComReqDto_1.setPeriodId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1489654_1_59752
queryStandardDataDetailComReqDto_1.setEntityId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1489643_1_59752
    }
if(reqDto!=null){
      queryStandardDataDetailComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1489660_1_59752
    }
if(judgeAutoReportVerifyProgressAndActualValueComRespDto!=null){
      queryStandardDataDetailComReqDto_1.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489655_1_59752
queryStandardDataDetailComReqDto_1.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489656_1_59752
queryStandardDataDetailComReqDto_1.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489693_1_59752
queryStandardDataDetailComReqDto_1.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489663_1_59752
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto_1.getDataType(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getPeriodId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getIsNewData(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getIsUpdateCycleNewData(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-是否更新周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getDataUsageSceneCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据使用场景编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getTableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getEntityId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getThemeContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getThemeContentId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getPersonLiableObjId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getBizRoleObjCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getPersonLiableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getBelongToPersonalIdentityId(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-数据归属个人ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getParentSubMidCycleType(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-父子中周期类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto_1.getSubjectLifeCycle(),"D3-执行自动汇报标准数据准备(公共)-D4-1查标准数据详情(公共)-主体生命周期不能为空",false);
      queryStandardDataDetailComRespDto_2 = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
RefreshAutoReportStandardDataComRespDto refreshAutoReportStandardDataComRespDto_1 = null;
    if(judgeAutoReportVerifyProgressAndActualValueComRespDto !=null&&queryStandardDataDetailComRespDto_2 !=null){
          RefreshAutoReportStandardDataComReqDto refreshAutoReportStandardDataComReqDto_1=new RefreshAutoReportStandardDataComReqDto();
  refreshAutoReportStandardDataComReqDto_1.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1489096_1_59742
if(receptionServiceRes!=null){
      refreshAutoReportStandardDataComReqDto_1.setDataType(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1489080_1_59742
    }
if(judgeAutoReportVerifyProgressAndActualValueComRespDto!=null){
      refreshAutoReportStandardDataComReqDto_1.setDataResult(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1489081_1_59742
refreshAutoReportStandardDataComReqDto_1.setUnit(judgeAutoReportVerifyProgressAndActualValueComRespDto.getUnit());//SimpleFieldAssign//sourceId:1489082_1_59742
refreshAutoReportStandardDataComReqDto_1.setUpdateCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489086_1_59742
refreshAutoReportStandardDataComReqDto_1.setUpdateCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489087_1_59742
refreshAutoReportStandardDataComReqDto_1.setUpdateCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489088_1_59742
refreshAutoReportStandardDataComReqDto_1.setCycleStartTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1489090_1_59742
refreshAutoReportStandardDataComReqDto_1.setCycleEndTime(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1489091_1_59742
refreshAutoReportStandardDataComReqDto_1.setCycleTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1489092_1_59742
refreshAutoReportStandardDataComReqDto_1.setCycleTypeInstanceCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1489093_1_59742
refreshAutoReportStandardDataComReqDto_1.setIsWorkCycleData(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1489094_1_59742
refreshAutoReportStandardDataComReqDto_1.setWorkCycleUpdateSlice(judgeAutoReportVerifyProgressAndActualValueComRespDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1489095_1_59742
refreshAutoReportStandardDataComReqDto_1.setParentSubMidCycleType(judgeAutoReportVerifyProgressAndActualValueComRespDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1489097_1_59742
refreshAutoReportStandardDataComReqDto_1.setStandardDataCalcCycleModel(judgeAutoReportVerifyProgressAndActualValueComRespDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1489098_1_59742
refreshAutoReportStandardDataComReqDto_1.setIsSystemDocking(judgeAutoReportVerifyProgressAndActualValueComRespDto.getIsSystemDocking());//SimpleFieldAssign//sourceId:1489099_1_59742
refreshAutoReportStandardDataComReqDto_1.setDataUsageSceneCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1489100_1_59742
refreshAutoReportStandardDataComReqDto_1.setPersonLiableObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1489101_1_59742
refreshAutoReportStandardDataComReqDto_1.setPersonLiableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1489104_1_59742
refreshAutoReportStandardDataComReqDto_1.setBizRoleObjId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1489102_1_59742
refreshAutoReportStandardDataComReqDto_1.setBizRoleObjCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1489105_1_59742
refreshAutoReportStandardDataComReqDto_1.setBizRoleObjName(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1489103_1_59742
refreshAutoReportStandardDataComReqDto_1.setBelongToPersonalIdentityTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1489115_1_59742
refreshAutoReportStandardDataComReqDto_1.setBelongToPersonalIdentityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1489116_1_59742
refreshAutoReportStandardDataComReqDto_1.setTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1489108_1_59742
refreshAutoReportStandardDataComReqDto_1.setEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getEntityId());//SimpleFieldAssign//sourceId:1489113_1_59742
refreshAutoReportStandardDataComReqDto_1.setBelongToContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1489110_1_59742
refreshAutoReportStandardDataComReqDto_1.setBelongToContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1489111_1_59742
refreshAutoReportStandardDataComReqDto_1.setCategoryContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getCategoryContentTypeCode());//SimpleFieldAssign//sourceId:1489118_1_59742
refreshAutoReportStandardDataComReqDto_1.setTopTargetCategoryID(judgeAutoReportVerifyProgressAndActualValueComRespDto.getTopTargetCategoryID());//SimpleFieldAssign//sourceId:1489119_1_59742
refreshAutoReportStandardDataComReqDto_1.setThemeContentTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentTypeCode());//SimpleFieldAssign//sourceId:1489106_1_59742
refreshAutoReportStandardDataComReqDto_1.setThemeContentId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getThemeContentId());//SimpleFieldAssign//sourceId:1489107_1_59742
refreshAutoReportStandardDataComReqDto_1.setFromContentTableTypeCode(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentTableTypeCode());//SimpleFieldAssign//sourceId:1489109_1_59742
refreshAutoReportStandardDataComReqDto_1.setFromContentEntityId(judgeAutoReportVerifyProgressAndActualValueComRespDto.getFromContentEntityId());//SimpleFieldAssign//sourceId:1489114_1_59742
    }
if(queryStandardDataDetailComRespDto_2!=null){
      refreshAutoReportStandardDataComReqDto_1.setParentDataResultId(queryStandardDataDetailComRespDto_2.getDataResultId());//SimpleFieldAssign//sourceId:1489083_1_59742
refreshAutoReportStandardDataComReqDto_1.setParentDataResult(queryStandardDataDetailComRespDto_2.getDataResult());//SimpleFieldAssign//sourceId:1489084_1_59742
    }
if(reqDto!=null){
      refreshAutoReportStandardDataComReqDto_1.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489085_1_59742
refreshAutoReportStandardDataComReqDto_1.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1489089_1_59742
    }

    /*D4-更新自动汇报更新标准数据(公共)[8305]   */
    Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getDataType(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getDataResult(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUnit(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleStartTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleEndTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getUpdateCycleTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleStartTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleEndTime(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCycleTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getIsWorkCycleData(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getWorkCycleUpdateSlice(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-工作周期更新切片不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getParentSubMidCycleType(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getStandardDataCalcCycleModel(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-标准数据计算周期模型不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getIsSystemDocking(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-是否系统对接不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getResultType(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getDataUsageSceneCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据使用场景编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getPersonLiableObjId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getPersonLiableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBizRoleObjId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBizRoleObjCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBizRoleObjName(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToPersonalIdentityTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人身份类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToPersonalIdentityId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属个人ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getTableTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getEntityId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getBelongToContentId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getCategoryContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-目标分类类型表类型不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getTopTargetCategoryID(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-一级目标分类ID不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getThemeContentTypeCode(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容类型编码不能为空",false);
Assert.isNull(refreshAutoReportStandardDataComReqDto_1.getThemeContentId(),"D3-执行自动汇报标准数据准备(公共)-D4-更新自动汇报更新标准数据(公共)-主题内容ID不能为空",false);
      refreshAutoReportStandardDataComRespDto_1 = fwCalcStandardDataClient.refreshAutoReportStandardDataCom(refreshAutoReportStandardDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
ImplementAutoReportStandardDataComRespDto retData = new ImplementAutoReportStandardDataComRespDto();
  if(judgeAutoReportVerifyProgressAndActualValueComRespDto_1!=null){
      retData.setAutoReportProgressValueVerify(judgeAutoReportVerifyProgressAndActualValueComRespDto_1.getAutoReportProgressValueVerify());//SimpleFieldAssign//sourceId:1489971_1
retData.setAutoReportActualValueVerify(judgeAutoReportVerifyProgressAndActualValueComRespDto_1.getAutoReportActualValueVerify());//SimpleFieldAssign//sourceId:1489972_1
    }




return retData;
  }
/**
   * D3执行循环增祖先目标周期资金来源预算标准数据(公共)[7715]
   * gen by moon at 1/31/2024, 8:44:54 PM
   */
  @Trace(operationName = "D3执行循环增祖先目标周期资金来源预算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto implementLoopAddAncestorContTargetCycleBudgetDataCom(ImplementLoopAddAncestorContTargetCycleBudgetDataComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getFinanceAccountList() !=null && reqDto.getFinanceAccountList().size()>0)) {
        //if(D4执行循环增祖先目标内容目标周期预算标准数据(公共).资金账户列表数据集条数 大于 0)  52014

//ModelCode: circulationCollections
        for (String circulationCollectionsRes: reqDto.getFinanceAccountList()){

QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1512615_1_60379
queryFinanceAccountDetailComReqDto.setIsStatisticalAccount("TRUE");//sourceId:1512616_1_60379
queryFinanceAccountDetailComReqDto.setIsArchive("FALSE");//sourceId:1512618_1_60379
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1512619_1_60379
if(circulationCollectionsRes!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1512617_1_60379
    }

    /*D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsStatisticalAccount(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-是否统计账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsArchive(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-是否存档不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D7查询当前内容资金账户详情(用于新增预算资金来源设置标准数据)-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



QueryEvaObjTargetCycleDetailComRespDto queryEvaObjTargetCycleDetailComRespDto = null;
    QueryEvaObjTargetCycleDetailComReqDto queryEvaObjTargetCycleDetailComReqDto=new QueryEvaObjTargetCycleDetailComReqDto();
  queryEvaObjTargetCycleDetailComReqDto.setIsArchive("FALSE");//sourceId:1244496_1_52018
if(reqDto!=null){
      queryEvaObjTargetCycleDetailComReqDto.setEvaObjEntityId(reqDto.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1244492_1_52018
queryEvaObjTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1244494_1_52018
queryEvaObjTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1244495_1_52018
    }
if(circulationCollectionsRes!=null){
      queryEvaObjTargetCycleDetailComReqDto.setTargetCycleContentId(circulationCollectionsRes);//SimpleFieldAssign//sourceId:1244493_1_52018
    }

    /*D3查当前牌目标周期(用于增标准数据入参)[3489]   */
    Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaObjEntityId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getTargetCycleContentId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getCycleId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailComReqDto.getIsArchive(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3查当前牌目标周期(用于增标准数据入参)-是否存档不能为空",false);
      queryEvaObjTargetCycleDetailComRespDto = targetCycleService.queryEvaObjTargetCycleDetailCom(queryEvaObjTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;



ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    if(queryEvaObjTargetCycleDetailComRespDto !=null){
          ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(queryEvaObjTargetCycleDetailComRespDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(queryEvaObjTargetCycleDetailComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1244598_1_52020
    }

    /*D3内容类型转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D3内容类型转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementDataResultAddOrReductionComRespDto implementDataResultAddOrReductionComRespDto = null;
    if(queryEvaObjTargetCycleDetailComRespDto !=null&&implementContentTypeChangeTableTypeComRespDto !=null&&queryFinanceAccountDetailComRespDto !=null){
          ImplementDataResultAddOrReductionComReqDto implementDataResultAddOrReductionComReqDto=new ImplementDataResultAddOrReductionComReqDto();
  implementDataResultAddOrReductionComReqDto.setResultType("SYSTEM_AUTO_COUNT");//sourceId:1512474_1_60373
implementDataResultAddOrReductionComReqDto.setIsWorkCycleData("TRUE");//sourceId:1512488_1_60373
implementDataResultAddOrReductionComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1512490_1_60373
implementDataResultAddOrReductionComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1512503_1_60373
implementDataResultAddOrReductionComReqDto.setCalcStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1512506_1_60373
implementDataResultAddOrReductionComReqDto.setUpdateBatch(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1512507_1_60373
if(reqDto!=null){
      implementDataResultAddOrReductionComReqDto.setBillTypeCode(reqDto.getBillTypeCode());//SimpleFieldAssign//sourceId:1512472_1_60373
implementDataResultAddOrReductionComReqDto.setDataUsageSceneCode(reqDto.getDataUsageSceneCode());//SimpleFieldAssign//sourceId:1512487_1_60373
implementDataResultAddOrReductionComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1512489_1_60373
implementDataResultAddOrReductionComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1512473_1_60373
implementDataResultAddOrReductionComReqDto.setUnit(reqDto.getUnit());//SimpleFieldAssign//sourceId:1512475_1_60373
implementDataResultAddOrReductionComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1512476_1_60373
implementDataResultAddOrReductionComReqDto.setExtendedField3(reqDto.getExtendedField3());//SimpleFieldAssign//sourceId:1512502_1_60373
implementDataResultAddOrReductionComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1512504_1_60373
implementDataResultAddOrReductionComReqDto.setPersonLiableObjId(reqDto.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1512492_1_60373
implementDataResultAddOrReductionComReqDto.setPersonLiableTypeCode(reqDto.getPersonLiableTypeCode());//SimpleFieldAssign//sourceId:1512496_1_60373
implementDataResultAddOrReductionComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1512493_1_60373
implementDataResultAddOrReductionComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1512494_1_60373
implementDataResultAddOrReductionComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1512495_1_60373
implementDataResultAddOrReductionComReqDto.setBelongToPersonalIdentityTypeCode(reqDto.getBelongToPersonalIdentityTypeCode());//SimpleFieldAssign//sourceId:1512498_1_60373
implementDataResultAddOrReductionComReqDto.setBelongToPersonalIdentityId(reqDto.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1512499_1_60373
implementDataResultAddOrReductionComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1512497_1_60373
    }
if(queryEvaObjTargetCycleDetailComRespDto!=null){
      implementDataResultAddOrReductionComReqDto.setPeriodId(queryEvaObjTargetCycleDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1512477_1_60373
implementDataResultAddOrReductionComReqDto.setCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1512478_1_60373
implementDataResultAddOrReductionComReqDto.setCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1512479_1_60373
implementDataResultAddOrReductionComReqDto.setCycleTypeCode(queryEvaObjTargetCycleDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1512480_1_60373
implementDataResultAddOrReductionComReqDto.setCycleTypeInstanceCode(queryEvaObjTargetCycleDetailComRespDto.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1512481_1_60373
implementDataResultAddOrReductionComReqDto.setUpdateCycleId(queryEvaObjTargetCycleDetailComRespDto.getCycleId());//SimpleFieldAssign//sourceId:1512482_1_60373
implementDataResultAddOrReductionComReqDto.setUpdateCycleStartTime(queryEvaObjTargetCycleDetailComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1512483_1_60373
implementDataResultAddOrReductionComReqDto.setUpdateCycleEndTime(queryEvaObjTargetCycleDetailComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1512484_1_60373
implementDataResultAddOrReductionComReqDto.setUpdateCycleTypeCode(queryEvaObjTargetCycleDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1512485_1_60373
implementDataResultAddOrReductionComReqDto.setEntityId(queryEvaObjTargetCycleDetailComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1512491_1_60373
implementDataResultAddOrReductionComReqDto.setBelongToContentId(queryEvaObjTargetCycleDetailComRespDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1512501_1_60373
    }
if(implementContentTypeChangeTableTypeComRespDto!=null){
      implementDataResultAddOrReductionComReqDto.setBelongToContentTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1512500_1_60373
    }
if(queryFinanceAccountDetailComRespDto!=null){
      implementDataResultAddOrReductionComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1512505_1_60373
    }

    /*D4新增预算资金来源祖先当前牌标准数据(公共)[8365]   */
    Assert.isNull(implementDataResultAddOrReductionComReqDto.getBillTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-收支类型不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getDataUsageSceneCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据使用场景编码不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getResultType(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-结果产生类型 不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getDataType(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据类型编码不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getDataResult(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据值结果不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getUnit(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-冗余单位不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getPeriodId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期ID不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getCycleStartTime(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期开始时间不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getCycleEndTime(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期结束时间不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getCycleTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-周期类型标识不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期ID不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleStartTime(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期开始时间不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleEndTime(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期结束时间不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateCycleTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-更新周期类型标识不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getIsWorkCycleData(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-是否工作周期数据不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getParentSubMidCycleType(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-父子中周期类型不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getTableTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-归属内容表类型编码不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getEntityId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getBelongToContentTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getBelongToContentId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getExtendedField3(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-扩展字段3不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getThemeContentTypeCode(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-主题内容类型编码不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getThemeContentId(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-主题内容ID不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getSubjectLifeCycle(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-主体生命周期不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getCalcStartTime(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-计算开始时间不能为空",false);
Assert.isNull(implementDataResultAddOrReductionComReqDto.getUpdateBatch(),"D3执行循环增祖先目标周期资金来源预算标准数据(公共)-D4新增预算资金来源祖先当前牌标准数据(公共)-数据更新批次（时间点）不能为空",false);
      implementDataResultAddOrReductionComRespDto = fwCalcStandardDataClient.implementDataResultAddOrReductionCom(implementDataResultAddOrReductionComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: circulationEnd
        }

      }
ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto retData = new ImplementLoopAddAncestorContTargetCycleBudgetDataComRespDto();





return retData;
  }
/**
   * D3-提交预算支出标准数据(公共)[8372]
   * gen by moon at 1/31/2024, 8:46:10 PM
   */
  @Trace(operationName = "D3-提交预算支出标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CommitBudgetDisburseStandardDataComRespDto commitBudgetDisburseStandardDataCom(CommitBudgetDisburseStandardDataComReqDto reqDto){


      //步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
     //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1515014_1
receptionServiceReq.setLastEvaObjTargetCycleId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1515039_1
receptionServiceReq.setLastCycleId(reqDto.getLastCycleId());//SimpleFieldAssign//sourceId:1515038_1
receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1515040_1
receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1515021_1
receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1515022_1
receptionServiceReq.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1515023_1
receptionServiceReq.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1515025_1
receptionServiceReq.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1515043_1
receptionServiceReq.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1515045_1
receptionServiceReq.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1515042_1
receptionServiceReq.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1515030_1
receptionServiceReq.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1515031_1
receptionServiceReq.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1515032_1
receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514941_1
receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1515073_1
receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1515113_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514972_1
receptionServiceReq.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1515046_1
receptionServiceReq.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1515047_1
receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1515114_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514939_1
receptionServiceReq.setExtendedField2(reqDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1515074_1
receptionServiceReq.setExtendedField3(reqDto.getContnetAccountSubjectld());//SimpleFieldAssign//sourceId:1515075_1
    }

    /*M3-接收入参字段[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDataResult(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-数据值结果不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期开始时间不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期结束时间不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleTypeCode(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-更新周期类型标识不能为空",false);
Assert.isNull(receptionServiceReq.getIsWorkCycleData(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-是否工作周期数据不能为空",false);
Assert.isNull(receptionServiceReq.getParentSubMidCycleType(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-父子中周期类型不能为空",false);
Assert.isNull(receptionServiceReq.getStandardDataCalcCycleModel(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-标准数据计算周期模型不能为空",false);
Assert.isNull(receptionServiceReq.getWorkCycleUpdateSlice(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-工作周期更新切片不能为空",false);
Assert.isNull(receptionServiceReq.getBizRoleObjId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(receptionServiceReq.getBizRoleObjCode(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(receptionServiceReq.getBizRoleObjName(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-关联目标内容类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getBelongToContentTypeCode(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-数据归属内容表类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getBelongToContentId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-数据归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-冗余目标ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3-提交预算支出标准数据(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbStandardData.implementFourthReceivingField(receptionServiceReq);




//步骤1: D3-执行提交预算条件分析(公共) - implementSubmitBudgetAnalyzeCom
     ImplementSubmitBudgetAnalyzeComRespDto implementSubmitBudgetAnalyzeComRespDto = null;
    ImplementSubmitBudgetAnalyzeComReqDto implementSubmitBudgetAnalyzeComReqDto=new ImplementSubmitBudgetAnalyzeComReqDto();
  if(reqDto!=null){
//      implementSubmitBudgetAnalyzeComReqDto.setBudget(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1515112_1
//implementSubmitBudgetAnalyzeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1515108_1
implementSubmitBudgetAnalyzeComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1515109_1
//implementSubmitBudgetAnalyzeComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1515110_1
implementSubmitBudgetAnalyzeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1515111_1
    }

    /*D3-执行提交预算条件分析（异常或不满足条件报错）[7704]   */
//    Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getBudget(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-预算金额不能为空",false);
//Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetCycleContentTypeCode(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-关联目标内容类型编码不能为空",false);
Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetCycleContentId(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-关联目标内容ID不能为空",false);
//Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetId(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-冗余目标ID不能为空",false);
Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getEvaluationTemplateId(),"D3-提交预算支出标准数据(公共)-D3-执行提交预算条件分析（异常或不满足条件报错）-冗余评价模板ID不能为空",false);
      implementSubmitBudgetAnalyzeComRespDto = financeService.implementSubmitBudgetAnalyzeCom(implementSubmitBudgetAnalyzeComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2-3查询分组匹配结果转答案(公共)(跨服务） - queryClassMatchResultToAnswerDetailCom
     QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1514726_1
queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("UNIT_CONFIG_CLASS");//CUSTOM_CONVENTION//sourceId:1514693_1
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1514772_1

    /*D2-3查预算金额单位（用于新增标准数据）[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"D3-提交预算支出标准数据(公共)-D2-3查预算金额单位（用于新增标准数据）-开通对象ID不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3-提交预算支出标准数据(公共)-D2-3查预算金额单位（用于新增标准数据）-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-提交预算支出标准数据(公共)-D2-3查预算金额单位（用于新增标准数据）-是否标准答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤3: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514961_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514959_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514960_1
    }

    /*3-3-09查目标周期详情（获取周期信息用于新增标准数据）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-提交预算支出标准数据(公共)-3-3-09查目标周期详情（获取周期信息用于新增标准数据）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-提交预算支出标准数据(公共)-3-3-09查目标周期详情（获取周期信息用于新增标准数据）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-提交预算支出标准数据(公共)-3-3-09查目标周期详情（获取周期信息用于新增标准数据）-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤4: D7-查询资金账户详情(公共) - queryFinanceAccountDetailCom
     QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    if(implementSubmitBudgetAnalyzeComRespDto !=null){
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setIsBudgetAccount("TRUE");//sourceId:1514968_1
queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514970_1
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1514971_1
if(implementSubmitBudgetAnalyzeComRespDto!=null){
//      queryFinanceAccountDetailComReqDto.setAccountObjectId(implementSubmitBudgetAnalyzeComRespDto.getAccountObjectId());//SimpleFieldAssign//sourceId:1514969_1
    }

    /*D7-查询预算账户ID（用于新增标准数据）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(),"D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3-提交预算支出标准数据(公共)-D7-查询预算账户ID（用于新增标准数据）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤5: D4-1提交标准数据(公共) - commitStandardDataCom
     CommitStandardDataComRespDto commitStandardDataComRespDto = null;
    if(queryClassMatchResultToAnswerDetailComRespDto !=null){
          CommitStandardDataComReqDto commitStandardDataComReqDto=new CommitStandardDataComReqDto();
  commitStandardDataComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1514905_1
commitStandardDataComReqDto.setResultType("MANUAL_INPUT");//sourceId:1514906_1
commitStandardDataComReqDto.setPersonLiableObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1514915_1
commitStandardDataComReqDto.setPersonLiableTypeCode("FILL_ROLE");//sourceId:1514916_1
commitStandardDataComReqDto.setBelongToPersonalIdentityTypeCode("OMS_ORG_INDUCTION_RECORD");//CUSTOM_CONVENTION//sourceId:1514934_1
commitStandardDataComReqDto.setBelongToPersonalIdentityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1514935_1
commitStandardDataComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1514933_1
commitStandardDataComReqDto.setTableTypeCode("OMS_EVALUATION_OBJECT_TARGET_CYCLE");//sourceId:1514900_1
commitStandardDataComReqDto.setFromContentTableTypeCode("OMS_TSPE_CYCLE_STAGE_DATA");//sourceId:1514901_1
commitStandardDataComReqDto.setThemeContentTypeCode("OMS_EVALUATION_TEMPLATE");//sourceId:1514923_1
commitStandardDataComReqDto.setSubjectLifeCycle("EDITING");//sourceId:1514920_1
if(reqDto!=null){
      commitStandardDataComReqDto.setDataResult(reqDto.getDataResult());//SimpleFieldAssign//sourceId:1514903_1
//commitStandardDataComReqDto.setLastEvaObjTargetCycleId(reqDto.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514907_1
//commitStandardDataComReqDto.setLastCycleId(reqDto.getLastCycleId());//SimpleFieldAssign//sourceId:1514908_1
commitStandardDataComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1514925_1
commitStandardDataComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1514930_1
commitStandardDataComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1514931_1
commitStandardDataComReqDto.setUpdateCycleTypeCode(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1514927_1
commitStandardDataComReqDto.setIsWorkCycleData(reqDto.getIsWorkCycleData());//SimpleFieldAssign//sourceId:1514932_1
commitStandardDataComReqDto.setParentSubMidCycleType(reqDto.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1514909_1
commitStandardDataComReqDto.setStandardDataCalcCycleModel(reqDto.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1514929_1
commitStandardDataComReqDto.setWorkCycleUpdateSlice(reqDto.getWorkCycleUpdateSlice());//SimpleFieldAssign//sourceId:1514928_1
commitStandardDataComReqDto.setBizRoleObjId(reqDto.getBizRoleObjId());//SimpleFieldAssign//sourceId:1514917_1
commitStandardDataComReqDto.setBizRoleObjCode(reqDto.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1514919_1
commitStandardDataComReqDto.setBizRoleObjName(reqDto.getBizRoleObjName());//SimpleFieldAssign//sourceId:1514918_1
//commitStandardDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1514899_1
//commitStandardDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1514902_1
commitStandardDataComReqDto.setBelongToContentTypeCode(reqDto.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1514921_1
commitStandardDataComReqDto.setBelongToContentId(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1514922_1
commitStandardDataComReqDto.setRootTargetCategoryId(reqDto.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1514926_1
commitStandardDataComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1514924_1
commitStandardDataComReqDto.setExtendedField3(reqDto.getContnetAccountSubjectld());//SimpleFieldAssign//sourceId:1514936_1
    }
if(queryClassMatchResultToAnswerDetailComRespDto!=null){
//      commitStandardDataComReqDto.setUnit(queryClassMatchResultToAnswerDetailComRespDto.getCashAccountUnit());//SimpleFieldAssign//sourceId:1514904_1
    }
if(omsEvaluationObjectTargetCycle!=null){
      commitStandardDataComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1514910_1
commitStandardDataComReqDto.setCycleStartTime(omsEvaluationObjectTargetCycle.getCycleStartTime());//SimpleFieldAssign//sourceId:1514911_1
commitStandardDataComReqDto.setCycleEndTime(omsEvaluationObjectTargetCycle.getCycleEndTime());//SimpleFieldAssign//sourceId:1514912_1
commitStandardDataComReqDto.setCycleTypeCode(omsEvaluationObjectTargetCycle.getCycleTypeCode());//SimpleFieldAssign//sourceId:1514913_1
commitStandardDataComReqDto.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1514914_1
    }
if(queryFinanceAccountDetailComRespDto!=null){
      commitStandardDataComReqDto.setAccountId(queryFinanceAccountDetailComRespDto.getAccountId());//SimpleFieldAssign//sourceId:1514937_1
    }

    /*D4-1提交标准数据（预算支出金额）[5640]   */
    Assert.isNull(commitStandardDataComReqDto.getDataResult(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据值结果不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getUnit(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-冗余单位不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getDataType(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getResultType(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-结果产生类型 不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getUpdateCycleId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-更新周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleStartTime(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期开始时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleEndTime(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期结束时间不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getCycleTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期类型标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getIsWorkCycleData(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-是否工作周期数据不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getParentSubMidCycleType(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-父子中周期类型不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getStandardDataCalcCycleModel(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-标准数据计算周期模型不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getWorkCycleUpdateSlice(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-工作周期更新切片不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getPersonLiableObjId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getPersonLiableTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBizRoleObjId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBizRoleObjCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBizRoleObjName(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToPersonalIdentityTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属个人身份类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToPersonalIdentityId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属个人ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getDataUsageSceneCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据使用场景编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getTableTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-归属内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto.getEvaObjTargetCycleId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-被评对象目标周期ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getFromContentTableTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-来自内容表类型编码不能为空",false);
//Assert.isNull(commitStandardDataComReqDto.getCycleStageDataId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-周期阶段资料记录ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToContentTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属内容表类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getBelongToContentId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-数据归属内容表主键ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getRootTargetCategoryId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-冗余一级目标分类ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getThemeContentTypeCode(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-主题内容类型编码不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getThemeContentId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-主题内容ID不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getSubjectLifeCycle(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-主体生命周期不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getExtendedField3(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-扩展字段3不能为空",false);
Assert.isNull(commitStandardDataComReqDto.getAccountId(),"D3-提交预算支出标准数据(公共)-D4-1提交标准数据（预算支出金额）-归属账户ID不能为空",false);
      commitStandardDataComRespDto = fwCalcStandardDataClient.commitStandardDataCom(commitStandardDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

CommitBudgetDisburseStandardDataComRespDto retData = new CommitBudgetDisburseStandardDataComRespDto();





return retData;
  }
/**
   * D3-提交预算支出数据准备(公共)[8372]
   * gen by moon at 3/13/2024, 5:22:33 AM
   */
  @Trace(operationName = "D3-提交预算支出数据准备(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CommitReadyForCommitActualValueAndBudgetStandardDataComRespDto commitReadyForCommitActualValueAndBudgetStandardDataCom(CommitReadyForCommitActualValueAndBudgetStandardDataComReqDto reqDto){


      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_1 =null;
if((reqDto!= null&& reqDto.getBudgetDisburse() != null )) {
        //if(D3-提交实际值及预算支出数据准备(公共).预算支出金额 值不等于空 )  60441

QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setAccountStatus("NORMAL");//sourceId:1562157_1_60444
queryFinanceAccountDetailComReqDto.setAccountTypeCode("ECOLOGICAL_ACCOUNT");//sourceId:1562207_1_60444
queryFinanceAccountDetailComReqDto.setEcologicalAccountTypeCode("TARGET_CONTENT_ACCOUNT");//sourceId:1562209_1_60444
queryFinanceAccountDetailComReqDto.setIsBudgetAccount("FALSE");//sourceId:1514968_1_60444
queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1514970_1_60444
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1514971_1_60444
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1514969_1_60444
    }

    /*D7-查实体账户详情（获取关联扣减的预算账户标识）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountStatus(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-账户状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountTypeCode(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-账户类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getEcologicalAccountTypeCode(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-生态账户类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3-提交预算支出数据准备(公共)-D7-查实体账户详情（获取关联扣减的预算账户标识）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryFinanceAccountDetailComRespDto_1 = queryFinanceAccountDetailComRespDto;
      }
      CommitReadyForCommitActualValueAndBudgetStandardDataComRespDto retData = new CommitReadyForCommitActualValueAndBudgetStandardDataComRespDto();
  if(queryFinanceAccountDetailComRespDto_1!=null){
      retData.setAccountId(queryFinanceAccountDetailComRespDto_1.getAccountId());//SimpleFieldAssign//sourceId:1580799_1
    }




return retData;
  }
/**
   * D3准备目标内容周期与相关人等入参数据(公共)[8539]
   * gen by moon at 5/22/2024, 2:41:01 PM
   */
  @Trace(operationName = "D3准备目标内容周期与相关人等入参数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public PreparationTargetCycleAndPeopleEternalGinsengComRespDto preparationTargetCycleAndPeopleEternalGinsengCom(PreparationTargetCycleAndPeopleEternalGinsengComReqDto reqDto){


      ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto_1 =null;
      PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengComRespDto_1 =null;
ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto_1 =null;
ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto_1 =null;
PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto_1 =null;
//virtualUsage D3内容类型转表类型(公共)  62163
      ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1567247_1_62163
    }

    /*D3内容类型转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3准备目标内容周期与相关人等入参数据(公共)-D3内容类型转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


      implementContentTypeChangeTableTypeComRespDto_1 = implementContentTypeChangeTableTypeComRespDto;
if((reqDto!= null&&  reqDto.getIsFinanceStandardData() !=null && reqDto.getIsFinanceStandardData().equals("TRUE"))) {
        //if(D3准备目标内容周期与相关人等入参数据(公共).是否财务标准数据 等于 是)  61959

if((reqDto!= null&& reqDto.getIsParentCycle() == null ||reqDto!= null&& reqDto.getEvaObjTargetCycleId() != null ||reqDto!= null&& reqDto.getCycleId() != null )) {
        //if((D3准备目标内容周期与相关人等入参数据(公共).是否父周期 值等于空  or D3准备目标内容周期与相关人等入参数据(公共).被评对象目标周期ID 值不等于空  or D3准备目标内容周期与相关人等入参数据(公共).周期ID 值不等于空 ))  61966

//异常结束 61967
      throw new BizException("C00028","对不起，没有数据！！",false);
      }
PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengComRespDto = null;
    PreparationTargetCycleEternalGinsengComReqDto preparationTargetCycleEternalGinsengComReqDto=new PreparationTargetCycleEternalGinsengComReqDto();
  if(reqDto!=null){
      preparationTargetCycleEternalGinsengComReqDto.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1563437_1_61963
preparationTargetCycleEternalGinsengComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563439_1_61963
preparationTargetCycleEternalGinsengComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563440_1_61963
    }

    /*D3准备目标内容周期等入参数据(公共)[8541]   */
    Assert.isNull(preparationTargetCycleEternalGinsengComReqDto.getTargetCycleContentId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(preparationTargetCycleEternalGinsengComReqDto.getEvaluationTemplateId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-冗余评价模板ID不能为空",false);
      preparationTargetCycleEternalGinsengComRespDto = preparationTargetCycleEternalGinsengCom(preparationTargetCycleEternalGinsengComReqDto)/*vcase invoke 同服务,同domain*/;


      preparationTargetCycleEternalGinsengComRespDto_1 = preparationTargetCycleEternalGinsengComRespDto;
ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto = null;
    ObtainTargetContNatureInfoComReqDto obtainTargetContNatureInfoComReqDto=new ObtainTargetContNatureInfoComReqDto();
  if(reqDto!=null){
      obtainTargetContNatureInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1565730_1_62034
obtainTargetContNatureInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1565731_1_62034
obtainTargetContNatureInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1565732_1_62034
    }

    /*D3获取目标内容属性信息(公共)[6952]   */
    Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainTargetContNatureInfoComReqDto.getTargetCycleContentTypeCode(),"D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(obtainTargetContNatureInfoComReqDto.getEvaluationTemplateId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-冗余评价模板ID不能为空",false);
      obtainTargetContNatureInfoComRespDto = indexSystemService.obtainTargetContNatureInfoCom(obtainTargetContNatureInfoComReqDto)/*vcase invoke isSameApp*/;


      obtainTargetContNatureInfoComRespDto_1 = obtainTargetContNatureInfoComRespDto;
ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto = null;
    ImplementStandardDataFillRoleInfoComReqDto implementStandardDataFillRoleInfoComReqDto=new ImplementStandardDataFillRoleInfoComReqDto();
  implementStandardDataFillRoleInfoComReqDto.setIsPersonCharge("TRUE");//sourceId:1563449_1_61971
implementStandardDataFillRoleInfoComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1563455_1_61971
if(reqDto!=null){
      implementStandardDataFillRoleInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563451_1_61971
    }

    /*D3准备相关人入参数据(公共)[8371]   */
    Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getIsPersonCharge(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-是否负责人不能为空",false);
Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getTargetCycleContentId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementStandardDataFillRoleInfoComReqDto.getUseScene(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-虚拟组织使用场景不能为空",false);
      implementStandardDataFillRoleInfoComRespDto = virtualOrgService.implementStandardDataFillRoleInfoCom(implementStandardDataFillRoleInfoComReqDto)/*vcase invoke isSameApp*/;


      implementStandardDataFillRoleInfoComRespDto_1 = implementStandardDataFillRoleInfoComRespDto;
      }
else if((reqDto!= null&&  reqDto.getIsFinanceStandardData() !=null && reqDto.getIsFinanceStandardData().equals("FALSE"))){
       //elseif(D3准备目标内容周期与相关人等入参数据(公共).是否财务标准数据 等于 否)  61960

if((reqDto!= null&& reqDto.getIsParentCycle() != null ||reqDto!= null&& reqDto.getEvaObjTargetCycleId() == null ||reqDto!= null&& reqDto.getCycleId() == null )) {
        //if((D3准备目标内容周期与相关人等入参数据(公共).是否父周期 值不等于空  or D3准备目标内容周期与相关人等入参数据(公共).被评对象目标周期ID 值等于空  or D3准备目标内容周期与相关人等入参数据(公共).周期ID 值等于空 ))  61969

//异常结束 61970
      throw new BizException("500","系统异常，请联系管理员！",false);
      }
PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengComRespDto_2 = null;
    PreparationTargetCycleEternalGinsengComReqDto preparationTargetCycleEternalGinsengComReqDto_1=new PreparationTargetCycleEternalGinsengComReqDto();
  if(reqDto!=null){
      preparationTargetCycleEternalGinsengComReqDto_1.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563438_1_61964
preparationTargetCycleEternalGinsengComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563439_1_61964
preparationTargetCycleEternalGinsengComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563440_1_61964
    }

    /*D3准备目标内容周期等入参数据(公共)[8541]   */
    Assert.isNull(preparationTargetCycleEternalGinsengComReqDto_1.getTargetCycleContentId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(preparationTargetCycleEternalGinsengComReqDto_1.getEvaluationTemplateId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备目标内容周期等入参数据(公共)-冗余评价模板ID不能为空",false);
      preparationTargetCycleEternalGinsengComRespDto_2 = preparationTargetCycleEternalGinsengCom(preparationTargetCycleEternalGinsengComReqDto_1)/*vcase invoke 同服务,同domain*/;


      preparationTargetCycleEternalGinsengComRespDto_1 = preparationTargetCycleEternalGinsengComRespDto_2;
ObtainTargetContNatureInfoComRespDto obtainTargetContNatureInfoComRespDto_2 = null;
    ObtainTargetContNatureInfoComReqDto obtainTargetContNatureInfoComReqDto_1=new ObtainTargetContNatureInfoComReqDto();
  if(reqDto!=null){
      obtainTargetContNatureInfoComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1565730_1_62035
obtainTargetContNatureInfoComReqDto_1.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1565731_1_62035
obtainTargetContNatureInfoComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1565732_1_62035
    }

    /*D3获取目标内容属性信息(公共)[6952]   */
    Assert.isNull(obtainTargetContNatureInfoComReqDto_1.getTargetCycleContentId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainTargetContNatureInfoComReqDto_1.getTargetCycleContentTypeCode(),"D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(obtainTargetContNatureInfoComReqDto_1.getEvaluationTemplateId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3获取目标内容属性信息(公共)-冗余评价模板ID不能为空",false);
      obtainTargetContNatureInfoComRespDto_2 = indexSystemService.obtainTargetContNatureInfoCom(obtainTargetContNatureInfoComReqDto_1)/*vcase invoke isSameApp*/;


      obtainTargetContNatureInfoComRespDto_1 = obtainTargetContNatureInfoComRespDto_2;
ImplementStandardDataFillRoleInfoComRespDto implementStandardDataFillRoleInfoComRespDto_2 = null;
    ImplementStandardDataFillRoleInfoComReqDto implementStandardDataFillRoleInfoComReqDto_1=new ImplementStandardDataFillRoleInfoComReqDto();
  implementStandardDataFillRoleInfoComReqDto_1.setIsPersonCharge("TRUE");//sourceId:1563449_1_61972
implementStandardDataFillRoleInfoComReqDto_1.setUseScene("TARGET_PLAN_SCENE");//sourceId:1563455_1_61972
if(reqDto!=null){
      implementStandardDataFillRoleInfoComReqDto_1.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563451_1_61972
    }

    /*D3准备相关人入参数据(公共)[8371]   */
    Assert.isNull(implementStandardDataFillRoleInfoComReqDto_1.getIsPersonCharge(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-是否负责人不能为空",false);
Assert.isNull(implementStandardDataFillRoleInfoComReqDto_1.getTargetCycleContentId(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementStandardDataFillRoleInfoComReqDto_1.getUseScene(),"D3准备目标内容周期与相关人等入参数据(公共)-D3准备相关人入参数据(公共)-虚拟组织使用场景不能为空",false);
      implementStandardDataFillRoleInfoComRespDto_2 = virtualOrgService.implementStandardDataFillRoleInfoCom(implementStandardDataFillRoleInfoComReqDto_1)/*vcase invoke isSameApp*/;


      implementStandardDataFillRoleInfoComRespDto_1 = implementStandardDataFillRoleInfoComRespDto_2;
PreparationPreviousStandardDataResultComRespDto preparationPreviousStandardDataResultComRespDto = null;
    PreparationPreviousStandardDataResultComReqDto preparationPreviousStandardDataResultComReqDto=new PreparationPreviousStandardDataResultComReqDto();
  if(reqDto!=null){
      preparationPreviousStandardDataResultComReqDto.setDataType(reqDto.getDataType());//SimpleFieldAssign//sourceId:1563839_1_61974
preparationPreviousStandardDataResultComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1563835_1_61974
preparationPreviousStandardDataResultComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801514_1_61974
preparationPreviousStandardDataResultComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1812448_1_61974
    }

    /*D4准备上一标准数据结果(公共)[8542]   */
    Assert.isNull(preparationPreviousStandardDataResultComReqDto.getDataType(),"D3准备目标内容周期与相关人等入参数据(公共)-D4准备上一标准数据结果(公共)-数据点类型不能为空",false);
      preparationPreviousStandardDataResultComRespDto = fwCalcStandardDataClient.preparationPreviousStandardDataResultCom(preparationPreviousStandardDataResultComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      preparationPreviousStandardDataResultComRespDto_1 = preparationPreviousStandardDataResultComRespDto;
    }
else{
       //else  61961

//异常结束 61962
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
PreparationTargetCycleAndPeopleEternalGinsengComRespDto retData = new PreparationTargetCycleAndPeopleEternalGinsengComRespDto();
  if(preparationPreviousStandardDataResultComRespDto_1!=null){
      retData.setDataResultId(preparationPreviousStandardDataResultComRespDto_1.getDataResultId());//SimpleFieldAssign//sourceId:1564266_1
retData.setDataResult(preparationPreviousStandardDataResultComRespDto_1.getDataResult());//SimpleFieldAssign//sourceId:1564267_1
    }
  if(preparationTargetCycleEternalGinsengComRespDto_1!=null){
retData.setCycleId(preparationTargetCycleEternalGinsengComRespDto_1.getCycleId());//SimpleFieldAssign//sourceId:1564046_1
retData.setCycleStartTime(preparationTargetCycleEternalGinsengComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1565463_1
retData.setCycleEndTime(preparationTargetCycleEternalGinsengComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1565464_1
retData.setCycleTypeCode(preparationTargetCycleEternalGinsengComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1564048_1
retData.setCycleTypeInstanceCode(preparationTargetCycleEternalGinsengComRespDto_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1564049_1
retData.setEvaObjTargetCycleId(preparationTargetCycleEternalGinsengComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1564044_1
retData.setTargetCycleContentId(preparationTargetCycleEternalGinsengComRespDto_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1564045_1
    }
if(implementContentTypeChangeTableTypeComRespDto_1!=null){
      retData.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:1567251_1
    }
if(obtainTargetContNatureInfoComRespDto_1!=null){
      retData.setRootTargetCategoryId(obtainTargetContNatureInfoComRespDto_1.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1565750_1
    }
if(implementStandardDataFillRoleInfoComRespDto_1!=null){
      retData.setVirtualOrgMemberId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgMemberId());//SimpleFieldAssign//sourceId:1580731_1
      retData.setVirtualOrgInductionRecordId(implementStandardDataFillRoleInfoComRespDto_1.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1564051_1
retData.setRoleId(implementStandardDataFillRoleInfoComRespDto_1.getRoleId());//SimpleFieldAssign//sourceId:1564052_1
retData.setRoleCode(implementStandardDataFillRoleInfoComRespDto_1.getRoleCode());//SimpleFieldAssign//sourceId:1564053_1
retData.setRoleName(implementStandardDataFillRoleInfoComRespDto_1.getRoleName());//SimpleFieldAssign//sourceId:1564054_1
    }




return retData;
  }
/**
   * D3获取公共字段入参[8540]
   * gen by moon at 5/9/2024, 11:21:23 AM
   */
  @Trace(operationName = "D3获取公共字段入参")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ObtainCalcStartTimeComRespDto obtainCalcStartTimeCom(ObtainCalcStartTimeComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
ImplementFiveReceivingFieldRespDto receptionServiceRes_3 =null;
OmsEvaluationTemplate omsEvaluationTemplate_1 =null;
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
      // TODO: 2024/5/5
  receptionServiceReq.setEventBatchUpdateCode("EVDB"+CommonFunctionHelper.getUid());//CUSTOM_CONVENTION//sourceId:1571415_1

    /*M3-准备数据1：事务内数据更新批次标识[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEventBatchUpdateCode(),"D3获取公共字段入参-M3-准备数据1：事务内数据更新批次标识-事务内数据更新批次标识不能为空",false);
      receptionServiceRes = nbStandardData.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;

//步骤1: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq_1.setCalcStartTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1563357_1

    /*M3-准备数据2：计算开始时间[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCalcStartTime(),"D3获取公共字段入参-M3-准备数据2：计算开始时间-计算开始时间不能为空",false);
      receptionServiceRes_2 = nbStandardData.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;

//步骤2: 3-2-02查评价模板详情 - queryEvaTempDetail
     OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1571378_1
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1571377_1
    }

    /*3-2-02准备数据3：评价主题ID、目标ID[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3获取公共字段入参-3-2-02准备数据3：评价主题ID、目标ID-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3获取公共字段入参-3-2-02准备数据3：评价主题ID、目标ID-主体生命周期不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationTemplate_1 = omsEvaluationTemplate;

ObtainCalcStartTimeComRespDto retData = new ObtainCalcStartTimeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setEventBatchUpdateCode(receptionServiceRes_1.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1571418_1
    }
if(receptionServiceRes_3!=null){
      retData.setCalcStartTime(receptionServiceRes_3.getCalcStartTime());//SimpleFieldAssign//sourceId:1563368_1
    }
if(omsEvaluationTemplate_1!=null){
      retData.setEvaluationSubjectId(omsEvaluationTemplate_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1571393_1
retData.setTargetId(omsEvaluationTemplate_1.getTargetId());//SimpleFieldAssign//sourceId:1571394_1
retData.setIsOpenBudget(omsEvaluationTemplate_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1579994_1
retData.setIsOpenBudgetReport(omsEvaluationTemplate_1.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1579995_1
    }




return retData;
  }
/**
   * D3准备目标内容周期等入参数据(公共)[8541]
   * gen by moon at 3/8/2024, 3:26:47 AM
   */
  @Trace(operationName = "D3准备目标内容周期等入参数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public PreparationTargetCycleEternalGinsengComRespDto preparationTargetCycleEternalGinsengCom(PreparationTargetCycleEternalGinsengComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
//步骤0: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1563269_1
queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1563273_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setIsParentCycle(reqDto.getIsParentCycle());//SimpleFieldAssign//sourceId:1563271_1
queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563274_1
queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563270_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563272_1
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3准备目标内容周期等入参数据(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() ==null,"找不到数据，系统异常",false);

      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

PreparationTargetCycleEternalGinsengComRespDto retData = new PreparationTargetCycleEternalGinsengComRespDto();
  if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563429_1
retData.setCyclelAlias(omsEvaluationObjectTargetCycle_1.getCyclelAlias());//SimpleFieldAssign//sourceId:1563430_1
retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1563431_1
retData.setCycleId(omsEvaluationObjectTargetCycle_1.getCycleId());//SimpleFieldAssign//sourceId:1563432_1
retData.setCycleStandardName(omsEvaluationObjectTargetCycle_1.getCycleStandardName());//SimpleFieldAssign//sourceId:1563433_1
retData.setCycleStartTime(omsEvaluationObjectTargetCycle_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1565459_1
retData.setCycleEndTime(omsEvaluationObjectTargetCycle_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1565460_1
retData.setCycleTypeCode(omsEvaluationObjectTargetCycle_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1563434_1
retData.setCycleTypeInstanceCode(omsEvaluationObjectTargetCycle_1.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1563435_1
retData.setCycleNumberShortName(omsEvaluationObjectTargetCycle_1.getCycleNumberShortName());//SimpleFieldAssign//sourceId:1563436_1
    }




return retData;
  }
/**
   * D3执行财务账户内容数据推redis(公共)[8563]
   * gen by moon at 6/6/2024, 9:23:07 PM
   */
  @Trace(operationName = "D3执行财务账户内容数据推redis(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSingleFinancialAccountContentDataPushRedisComRespDto implementSingleFinancialAccountContentDataPushRedisCom(ImplementSingleFinancialAccountContentDataPushRedisComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getIsLastCycle() !=null && reqDto.getIsLastCycle().equals("TRUE")&&reqDto!= null&& reqDto.getAccountId() != null )) {
        //if((D3执行财务账户内容数据推redis(公共).是否末级周期 等于 是 and D3执行财务账户内容数据推redis(公共).账户ID 值不等于空 ))  62229

      QueryFullTemplateFundAccountListComRespDto queryFullTemplateFundAccountListComRespDto = null;
    QueryFullTemplateFundAccountListComReqDto queryFullTemplateFundAccountListComReqDto=new QueryFullTemplateFundAccountListComReqDto();
  queryFullTemplateFundAccountListComReqDto.setAccountObjectClass("CONTENT_TYPE");//sourceId:1569776_1_62230
queryFullTemplateFundAccountListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1569778_1_62230
if(reqDto!=null){
      queryFullTemplateFundAccountListComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1569777_1_62230
queryFullTemplateFundAccountListComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1569779_1_62230
    }

    /*D7查全模板资金账户列表（用于刷全模板资金账户发牌）[8564]   */
    Assert.isNull(queryFullTemplateFundAccountListComReqDto.getThemeContentId(),"D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-主题内容ID不能为空",false);
Assert.isNull(queryFullTemplateFundAccountListComReqDto.getAccountObjectClass(),"D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-账户关联主体分类类型不能为空",false);
Assert.isNull(queryFullTemplateFundAccountListComReqDto.getSubjectLifeCycle(),"D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-主体生命周期不能为空",false);
Assert.isNull(queryFullTemplateFundAccountListComReqDto.getSpaceId(),"D3执行财务账户内容数据推redis(公共)-D7查全模板资金账户列表（用于刷全模板资金账户发牌）-创建于空间ID不能为空",false);
      queryFullTemplateFundAccountListComRespDto = fwFinanceFinanceClient.queryFullTemplateFundAccountListCom(queryFullTemplateFundAccountListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryFullTemplateFundAccountListComRespDto!= null&&  queryFullTemplateFundAccountListComRespDto.getFinanceAccountList() !=null && queryFullTemplateFundAccountListComRespDto.getFinanceAccountList().size()>0)) {
        //if(D7查全模板资金账户列表（用于刷全模板资金账户发牌）.资金账户列表数据集条数 大于 0)  62231

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryTargetContetCycleDetailReq queryTargetContetCycleDetailReq=new QueryTargetContetCycleDetailReq();
  queryTargetContetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1799661_1_68428
if(reqDto!=null){
      queryTargetContetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799659_1_68428
queryTargetContetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1799660_1_68428
queryTargetContetCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1799662_1_68428
    }

    /*3-3-09查询目标内容周期详情[9285]   */
    Assert.isNull(queryTargetContetCycleDetailReq.getEvaObjTargetCycleId(),"D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetContetCycleDetailReq.getEvaluationTemplateId(),"D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetContetCycleDetailReq.getSubjectLifeCycle(),"D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-主体生命周期不能为空",false);
Assert.isNull(queryTargetContetCycleDetailReq.getSpaceId(),"D3执行财务账户内容数据推redis(公共)-3-3-09查询目标内容周期详情-创建于空间ID不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryTargetContetCycleDetail(queryTargetContetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: circulationCollections
        for (com.wicket.okrfinance.integration.dto.FinanceAccountDto circulationCollectionsRes: queryFullTemplateFundAccountListComRespDto.getFinanceAccountList()){

OmsTargetAttributionCycle omsTargetAttributionCycle = null;
    if(omsEvaluationObjectTargetCycle !=null){
    QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq=new QueryTargetBelongCycleDetailReq();
  queryTargetBelongCycleDetailReq.setParentSubMidCycleType("PARENT_CYCLE");//sourceId:1608414_1_63112
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetBelongCycleDetailReq.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1799666_1_63112
queryTargetBelongCycleDetailReq.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1799667_1_63112
    }
if(circulationCollectionsRes!=null){
      queryTargetBelongCycleDetailReq.setBelongToContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1608417_1_63112
    }
if(reqDto!=null){
      queryTargetBelongCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1608500_1_63112
queryTargetBelongCycleDetailReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1608412_1_63112
    }

    /*3-3-09-07查询目标归属父周期详情[8579]   */
    Assert.isNull(queryTargetBelongCycleDetailReq.getEvaObjEntityId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq.getEvaObjTypeCode(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq.getBelongToContentId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq.getParentSubMidCycleType(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq.getEvaluationTemplateId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属父周期详情-冗余评价模板ID不能为空",false);
      omsTargetAttributionCycle = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



           }
AddTargetCycleAndPeopleEternalGinsengRedisComRespDto addTargetCycleAndPeopleEternalGinsengRedisComRespDto = null;
    if(omsTargetAttributionCycle !=null&&omsEvaluationObjectTargetCycle !=null){
          AddTargetCycleAndPeopleEternalGinsengRedisComReqDto addTargetCycleAndPeopleEternalGinsengRedisComReqDto=new AddTargetCycleAndPeopleEternalGinsengRedisComReqDto();
  addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setBusinessDataObject("ACCT_STD_DATA_TARGET_CONT_SNAP");//sourceId:1570033_1_62235
if(reqDto!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1570034_1_62235
    }
if(omsTargetAttributionCycle!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue16(omsTargetAttributionCycle.getPreviousCycleId());//SimpleFieldAssign//sourceId:1799687_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue17(omsTargetAttributionCycle.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799688_1_62235
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue1(omsTargetAttributionCycle.getTargetCycleId());//SimpleFieldAssign//sourceId:1570035_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue2(omsTargetAttributionCycle.getTargetCycleStartTime()!=null?String.valueOf(omsTargetAttributionCycle.getTargetCycleStartTime()):"");//SimpleFieldAssign//sourceId:1570036_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue3(omsTargetAttributionCycle.getTargetCycleEndTime()!=null?String.valueOf(omsTargetAttributionCycle.getTargetCycleEndTime()):"");//SimpleFieldAssign//sourceId:1570037_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue4(omsTargetAttributionCycle.getTargetCycleTypeCode());//SimpleFieldAssign//sourceId:1570038_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue5(omsTargetAttributionCycle.getTargetCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1570039_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue7(omsTargetAttributionCycle.getEntityId());//SimpleFieldAssign//sourceId:1570041_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue8(omsTargetAttributionCycle.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1570042_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue9(omsTargetAttributionCycle.getBelongToContentId());//SimpleFieldAssign//sourceId:1570043_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue10(omsTargetAttributionCycle.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1570044_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue11(omsTargetAttributionCycle.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1570045_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue12(omsTargetAttributionCycle.getBizRoleObjId());//SimpleFieldAssign//sourceId:1570046_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue13(omsTargetAttributionCycle.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1570047_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue14(omsTargetAttributionCycle.getBizRoleObjName());//SimpleFieldAssign//sourceId:1570048_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue15(omsTargetAttributionCycle.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1608769_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue20(omsTargetAttributionCycle.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1853109_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue21(omsTargetAttributionCycle.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1853110_1_62235
    }
if(omsEvaluationObjectTargetCycle!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue19(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815799_1_62235
addTargetCycleAndPeopleEternalGinsengRedisComReqDto.setCustomFieldValue18(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815800_1_62235
    }

    /*D2新增目标内容周期与相关人等入参数据推reids(公共)[8565]   */
    Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getBusinessDataObject(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-业务数据对象不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue1(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue2(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期开始时间不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue3(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期结束时间不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue4(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期类型标识不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue19(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue18(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象类型编码不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue7(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue8(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue9(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue11(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue12(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue13(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue14(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue15(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属个人ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue20(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto.getCustomFieldValue21(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-本目标归属周期的计算周期五模型不能为空",false);
      addTargetCycleAndPeopleEternalGinsengRedisComRespDto = fwCompStandardDataClient.addTargetCycleAndPeopleEternalGinsengRedisCom(addTargetCycleAndPeopleEternalGinsengRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((reqDto!= null&&  reqDto.getOpenMidCycle() !=null && reqDto.getOpenMidCycle().equals("TRUE"))) {
        //if(D3执行财务账户内容数据推redis(公共).是否开启中期 等于 是)  68425

OmsTargetAttributionCycle omsTargetAttributionCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq_1=new QueryTargetBelongCycleDetailReq();
  queryTargetBelongCycleDetailReq_1.setParentSubMidCycleType("MID_CYCLE");//sourceId:1799670_1_68426
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetBelongCycleDetailReq_1.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1799668_1_68426
queryTargetBelongCycleDetailReq_1.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1799669_1_68426
    }
if(circulationCollectionsRes!=null){
      queryTargetBelongCycleDetailReq_1.setBelongToContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1799671_1_68426
    }
if(reqDto!=null){
      queryTargetBelongCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1799672_1_68426
queryTargetBelongCycleDetailReq_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1799673_1_68426
    }

    /*3-3-09-07查询目标归属中周期详情[8579]   */
    Assert.isNull(queryTargetBelongCycleDetailReq_1.getEvaObjEntityId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_1.getEvaObjTypeCode(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_1.getParentSubMidCycleType(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_1.getBelongToContentId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_1.getEvaluationTemplateId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_1.getSpaceId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属中周期详情-创建于空间ID不能为空",false);
      omsTargetAttributionCycle_2 = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
AddTargetCycleAndPeopleEternalGinsengRedisComRespDto addTargetCycleAndPeopleEternalGinsengRedisComRespDto_1 = null;
    if(omsTargetAttributionCycle_2 !=null&&omsEvaluationObjectTargetCycle !=null){
          AddTargetCycleAndPeopleEternalGinsengRedisComReqDto addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1=new AddTargetCycleAndPeopleEternalGinsengRedisComReqDto();
  addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setBusinessDataObject("ACCT_STD_DATA_TARGET_CONT_SNAP");//sourceId:1570033_1_68427
if(reqDto!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1570034_1_68427
    }
if(omsTargetAttributionCycle_2!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue16(omsTargetAttributionCycle_2.getPreviousCycleId());//SimpleFieldAssign//sourceId:1799687_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue17(omsTargetAttributionCycle_2.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799688_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue1(omsTargetAttributionCycle_2.getCycleId());//SimpleFieldAssign//sourceId:1570035_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue2(omsTargetAttributionCycle_2.getCycleStartTime()!=null?String.valueOf(omsTargetAttributionCycle_2.getCycleStartTime()):"");//SimpleFieldAssign//sourceId:1570036_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue3(omsTargetAttributionCycle_2.getCycleEndTime()!=null?String.valueOf(omsTargetAttributionCycle_2.getCycleEndTime()):"");//SimpleFieldAssign//sourceId:1570037_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue4(omsTargetAttributionCycle_2.getCycleTypeCode());//SimpleFieldAssign//sourceId:1570038_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue5(omsTargetAttributionCycle_2.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1570039_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue7(omsTargetAttributionCycle_2.getEntityId());//SimpleFieldAssign//sourceId:1570041_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue8(omsTargetAttributionCycle_2.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1570042_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue9(omsTargetAttributionCycle_2.getBelongToContentId());//SimpleFieldAssign//sourceId:1570043_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue10(omsTargetAttributionCycle_2.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1570044_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue11(omsTargetAttributionCycle_2.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1570045_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue12(omsTargetAttributionCycle_2.getBizRoleObjId());//SimpleFieldAssign//sourceId:1570046_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue13(omsTargetAttributionCycle_2.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1570047_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue14(omsTargetAttributionCycle_2.getBizRoleObjName());//SimpleFieldAssign//sourceId:1570048_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue15(omsTargetAttributionCycle_2.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1608769_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue20(omsTargetAttributionCycle_2.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1853109_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue21(omsTargetAttributionCycle_2.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1853110_1_68427
    }

        if(omsEvaluationObjectTargetCycle!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue19(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815799_1_68427
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.setCustomFieldValue18(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815800_1_68427
        }

    /*D2新增目标内容周期与相关人等入参数据推reids(公共)[8565]   */
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getBusinessDataObject(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-业务数据对象不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue1(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue2(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期开始时间不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue3(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期结束时间不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue4(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期类型标识不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue19(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue18(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象类型编码不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue7(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue8(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue9(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue11(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue12(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue13(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue14(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue15(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属个人ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue20(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1.getCustomFieldValue21(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-本目标归属周期的计算周期五模型不能为空",false);
      addTargetCycleAndPeopleEternalGinsengRedisComRespDto_1 = fwCompStandardDataClient.addTargetCycleAndPeopleEternalGinsengRedisCom(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
OmsTargetAttributionCycle omsTargetAttributionCycle_4 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryTargetBelongCycleDetailReq queryTargetBelongCycleDetailReq_2=new QueryTargetBelongCycleDetailReq();
  queryTargetBelongCycleDetailReq_2.setParentSubMidCycleType("SUB_CYCLE");//sourceId:1799680_1_68429
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetBelongCycleDetailReq_2.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1799674_1_68429
queryTargetBelongCycleDetailReq_2.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1799675_1_68429
queryTargetBelongCycleDetailReq_2.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1799676_1_68429
    }
if(circulationCollectionsRes!=null){
      queryTargetBelongCycleDetailReq_2.setBelongToContentId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1799677_1_68429
    }
if(reqDto!=null){
      queryTargetBelongCycleDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1799678_1_68429
queryTargetBelongCycleDetailReq_2.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1799679_1_68429
    }

    /*3-3-09-07查询目标归属子周期详情[8579]   */
    Assert.isNull(queryTargetBelongCycleDetailReq_2.getEvaObjEntityId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-主树被评对象内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_2.getEvaObjTypeCode(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-主树被评对象类型编码不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_2.getCycleId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-归属周期ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_2.getParentSubMidCycleType(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-父子中过程周期类型不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_2.getBelongToContentId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-数据归属内容表主键ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_2.getEvaluationTemplateId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBelongCycleDetailReq_2.getSpaceId(),"D3执行财务账户内容数据推redis(公共)-3-3-09-07查询目标归属子周期详情-创建于空间ID不能为空",false);
      omsTargetAttributionCycle_4 = mOmsTargetAttributionCycleService.queryTargetBelongCycleDetail(queryTargetBelongCycleDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
AddTargetCycleAndPeopleEternalGinsengRedisComRespDto addTargetCycleAndPeopleEternalGinsengRedisComRespDto_2 = null;
    if(omsTargetAttributionCycle_4 !=null&&omsEvaluationObjectTargetCycle !=null){
          AddTargetCycleAndPeopleEternalGinsengRedisComReqDto addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2=new AddTargetCycleAndPeopleEternalGinsengRedisComReqDto();
  addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setBusinessDataObject("ACCT_STD_DATA_TARGET_CONT_SNAP");//sourceId:1570033_1_68430
if(reqDto!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1570034_1_68430
    }
if(omsTargetAttributionCycle_4!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue16(omsTargetAttributionCycle_4.getPreviousCycleId());//SimpleFieldAssign//sourceId:1799687_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue17(omsTargetAttributionCycle_4.getLastEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1799688_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue1(omsTargetAttributionCycle_4.getCycleId());//SimpleFieldAssign//sourceId:1570035_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue2(omsTargetAttributionCycle_4.getCycleStartTime()!=null?String.valueOf(omsTargetAttributionCycle_4.getCycleStartTime()):"");//SimpleFieldAssign//sourceId:1570036_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue3(omsTargetAttributionCycle_4.getCycleEndTime()!=null?String.valueOf(omsTargetAttributionCycle_4.getCycleEndTime()):"");//SimpleFieldAssign//sourceId:1570037_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue4(omsTargetAttributionCycle_4.getCycleTypeCode());//SimpleFieldAssign//sourceId:1570038_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue5(omsTargetAttributionCycle_4.getCycleTypeInstanceCode());//SimpleFieldAssign//sourceId:1570039_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue7(omsTargetAttributionCycle_4.getEntityId());//SimpleFieldAssign//sourceId:1570041_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue8(omsTargetAttributionCycle_4.getBelongToContentTypeCode());//SimpleFieldAssign//sourceId:1570042_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue9(omsTargetAttributionCycle_4.getBelongToContentId());//SimpleFieldAssign//sourceId:1570043_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue10(omsTargetAttributionCycle_4.getOneLevelCategoryId());//SimpleFieldAssign//sourceId:1570044_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue11(omsTargetAttributionCycle_4.getPersonLiableObjId());//SimpleFieldAssign//sourceId:1570045_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue12(omsTargetAttributionCycle_4.getBizRoleObjId());//SimpleFieldAssign//sourceId:1570046_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue13(omsTargetAttributionCycle_4.getBizRoleObjCode());//SimpleFieldAssign//sourceId:1570047_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue14(omsTargetAttributionCycle_4.getBizRoleObjName());//SimpleFieldAssign//sourceId:1570048_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue15(omsTargetAttributionCycle_4.getBelongToPersonalIdentityId());//SimpleFieldAssign//sourceId:1608769_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue20(omsTargetAttributionCycle_4.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1853109_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue21(omsTargetAttributionCycle_4.getStandardDataCalcCycleModel());//SimpleFieldAssign//sourceId:1853110_1_68430
    }
        if(omsEvaluationObjectTargetCycle!=null){
      addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue19(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1815799_1_68430
addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.setCustomFieldValue18(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1815800_1_68430
        }
    /*D2新增目标内容周期与相关人等入参数据推reids(公共)[8565]   */
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getBusinessDataObject(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-业务数据对象不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue1(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue2(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期开始时间不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue3(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期结束时间不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue4(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-周期类型标识不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue19(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue18(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-被评对象类型编码不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue7(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue8(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表类型编码不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue9(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属内容表主键ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue11(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人对象ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue12(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue13(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色标识不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue14(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-填报评价责任人业务角色对象名称不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue15(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-数据归属个人ID不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue20(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-父子中过程周期类型不能为空",false);
Assert.isNull(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2.getCustomFieldValue21(),"D3执行财务账户内容数据推redis(公共)-D2新增目标内容周期与相关人等入参数据推reids(公共)-本目标归属周期的计算周期五模型不能为空",false);
      addTargetCycleAndPeopleEternalGinsengRedisComRespDto_2 = fwCompStandardDataClient.addTargetCycleAndPeopleEternalGinsengRedisCom(addTargetCycleAndPeopleEternalGinsengRedisComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//ModelCode: circulationEnd
        }

      }
      }
ImplementSingleFinancialAccountContentDataPushRedisComRespDto retData = new ImplementSingleFinancialAccountContentDataPushRedisComRespDto();





return retData;
  }
/**
   * D3-执行计算主观得分数据准备(公共)[8535]
   * gen by moon at 3/13/2024, 5:20:15 AM
   */
  @Trace(operationName = "D3-执行计算主观得分数据准备(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementPrepareForSubjectiveScoreComRespDto implementPrepareForSubjectiveScoreCom(ImplementPrepareForSubjectiveScoreComReqDto reqDto){


      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto_1 =null;
OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet_1 =null;
QueryTargetContExSetDetailComRespDto queryTargetContExSetDetailComRespDto_1 =null;
//步骤0: M3执行第四接收字段（特殊方法） - implementFourthReceivingField
     //ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1561331_1
receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1561332_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1561333_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561330_1
    }

    /*M3-接收入参字段[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-关联目标内容类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3-执行计算主观得分数据准备(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbStandardData.implementFourthReceivingField(receptionServiceReq);




//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
     QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("SUBJECTIVE_RATING_TOTAL_VALUE");//CUSTOM_CONVENTION//sourceId:1561197_1
//queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1561198_1
//if(reqDto!=null){
//      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561196_1
//    }

    /*D2-3查主观评分满分值[2486]   */
//    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-执行计算主观得分数据准备(公共)-D2-3查主观评分满分值-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-执行计算主观得分数据准备(公共)-D2-3查主观评分满分值-配置项标识不能为空",false);
//Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-执行计算主观得分数据准备(公共)-D2-3查主观评分满分值-是否标准答案不能为空",false);
//      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;

//步骤2: D2-3查询分组匹配结果转答案(公共)(跨服务） - queryClassMatchResultToAnswerDetailCom
     QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("DECIMAL_POINT_RULES_SET_CLASS");//CUSTOM_CONVENTION//sourceId:1561306_1
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1561307_1
if(reqDto!=null){
      queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561305_1
    }

    /*D2-3查小数规则配置[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"D3-执行计算主观得分数据准备(公共)-D2-3查小数规则配置-开通对象ID不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3-执行计算主观得分数据准备(公共)-D2-3查小数规则配置-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-执行计算主观得分数据准备(公共)-D2-3查小数规则配置-是否标准答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryClassMatchResultToAnswerDetailComRespDto_1 = queryClassMatchResultToAnswerDetailComRespDto;

//步骤3: 3-3-09-02查被评对象目标周期权重详情 - queryEvaObjTargetCycleWeightDetail
     OmsEvaObjTargetCycleWeightSet omsEvaObjTargetCycleWeightSet = null;
    QueryEvaObjTargetCycleWeightDetailReq queryEvaObjTargetCycleWeightDetailReq=new QueryEvaObjTargetCycleWeightDetailReq();
  queryEvaObjTargetCycleWeightDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1561341_1
if(reqDto!=null){
      queryEvaObjTargetCycleWeightDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1561339_1
queryEvaObjTargetCycleWeightDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561340_1
    }

    /*3-3-09-02查被评对象目标周期权重详情[2649]   */
    Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaObjTargetCycleId(),"D3-执行计算主观得分数据准备(公共)-3-3-09-02查被评对象目标周期权重详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getEvaluationTemplateId(),"D3-执行计算主观得分数据准备(公共)-3-3-09-02查被评对象目标周期权重详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleWeightDetailReq.getSubjectLifeCycle(),"D3-执行计算主观得分数据准备(公共)-3-3-09-02查被评对象目标周期权重详情-主体生命周期不能为空",false);
      omsEvaObjTargetCycleWeightSet = mOmsEvaObjTargetCycleWeightSetService.queryEvaObjTargetCycleWeightDetail(queryEvaObjTargetCycleWeightDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaObjTargetCycleWeightSet_1 = omsEvaObjTargetCycleWeightSet;

//步骤4: D3执行内容类型互转表类型(公共) - implementContentTypeChangeTableTypeCom
     ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1561348_1
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3-执行计算主观得分数据准备(公共)-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;




//步骤5: D3-查询目标内容扩展设置(公共) - queryTargetContExSetDetailCom
     QueryTargetContExSetDetailComRespDto queryTargetContExSetDetailComRespDto = null;
    if(implementContentTypeChangeTableTypeComRespDto !=null){
          QueryTargetContExSetDetailComReqDto queryTargetContExSetDetailComReqDto=new QueryTargetContExSetDetailComReqDto();
  if(implementContentTypeChangeTableTypeComRespDto!=null){
      queryTargetContExSetDetailComReqDto.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1561344_1
    }
if(reqDto!=null){
      queryTargetContExSetDetailComReqDto.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1561345_1
queryTargetContExSetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1561343_1
    }

    /*D3-查询目标内容扩展设置(公共)[5107]   */
    Assert.isNull(queryTargetContExSetDetailComReqDto.getTableTypeCode(),"D3-执行计算主观得分数据准备(公共)-D3-查询目标内容扩展设置(公共)-冗余内容表类型编码不能为空",false);
Assert.isNull(queryTargetContExSetDetailComReqDto.getEntityId(),"D3-执行计算主观得分数据准备(公共)-D3-查询目标内容扩展设置(公共)-冗余内容表主键ID不能为空",false);
Assert.isNull(queryTargetContExSetDetailComReqDto.getEvaluationTemplateId(),"D3-执行计算主观得分数据准备(公共)-D3-查询目标内容扩展设置(公共)-冗余评价模板ID不能为空",false);
      queryTargetContExSetDetailComRespDto = indexSystemService.queryTargetContExSetDetailCom(queryTargetContExSetDetailComReqDto)/*vcase invoke isSameApp*/;


      queryTargetContExSetDetailComRespDto_1 = queryTargetContExSetDetailComRespDto;
           }

ImplementPrepareForSubjectiveScoreComRespDto retData = new ImplementPrepareForSubjectiveScoreComRespDto();
  if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setSubjectiveRatingTotalValue(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:1561310_1
    }
if(queryClassMatchResultToAnswerDetailComRespDto_1!=null){
      retData.setSubjectiveScorePoint(queryClassMatchResultToAnswerDetailComRespDto_1.getSubjectiveScorePoint());//SimpleFieldAssign//sourceId:1561308_1
retData.setDecimalDigitsLastRules(queryClassMatchResultToAnswerDetailComRespDto_1.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1561309_1
    }
if(omsEvaObjTargetCycleWeightSet_1!=null){
      retData.setWeightScore(omsEvaObjTargetCycleWeightSet_1.getWeightScore());//SimpleFieldAssign//sourceId:1561342_1
    }
if(queryTargetContExSetDetailComRespDto_1!=null){
      retData.setReportObjectSetCode(queryTargetContExSetDetailComRespDto_1.getReportObjectSetCode());//SimpleFieldAssign//sourceId:1561352_1
    }




return retData;
  }
/**
   * D3准备标准数据内容及周期数据(公共)[8650]
   * gen by moon at 4/24/2024, 4:11:54 PM
   */
  @Trace(operationName = "D3准备标准数据内容及周期数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public PreparationStandardDataContAndCycleComRespDto preparationStandardDataContAndCycleCom(PreparationStandardDataContAndCycleComReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto_1 =null;
//步骤0: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1612875_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1612873_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1612874_1
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3准备标准数据内容及周期数据(公共)-3-3-09查被评对象目标周期详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3准备标准数据内容及周期数据(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3准备标准数据内容及周期数据(公共)-3-3-09查被评对象目标周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;

//步骤1: D3获取当前目标内容执行周期(公共) - obtainCurrentTargetContexeCuteCycleCom
     ObtainCurrentTargetContexeCuteCycleComRespDto obtainCurrentTargetContexeCuteCycleComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ObtainCurrentTargetContexeCuteCycleComReqDto obtainCurrentTargetContexeCuteCycleComReqDto=new ObtainCurrentTargetContexeCuteCycleComReqDto();
  if(reqDto!=null){
      obtainCurrentTargetContexeCuteCycleComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1612755_1
obtainCurrentTargetContexeCuteCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1612758_1
    }
if(omsEvaluationObjectTargetCycle!=null){
      obtainCurrentTargetContexeCuteCycleComReqDto.setTargetCycleContentId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1612756_1
obtainCurrentTargetContexeCuteCycleComReqDto.setTargetId(omsEvaluationObjectTargetCycle.getTargetId());//SimpleFieldAssign//sourceId:1612757_1
    }

    /*D3获取当前目标内容执行周期(公共)[7501]   */
    Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getCycleId(),"D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-周期ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetCycleContentId(),"D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getTargetId(),"D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-冗余目标ID不能为空",false);
Assert.isNull(obtainCurrentTargetContexeCuteCycleComReqDto.getEvaluationTemplateId(),"D3准备标准数据内容及周期数据(公共)-D3获取当前目标内容执行周期(公共)-冗余评价模板ID不能为空",false);
      obtainCurrentTargetContexeCuteCycleComRespDto = executeCycleService.obtainCurrentTargetContexeCuteCycleCom(obtainCurrentTargetContexeCuteCycleComReqDto)/*vcase invoke isSameApp*/;


      obtainCurrentTargetContexeCuteCycleComRespDto_1 = obtainCurrentTargetContexeCuteCycleComRespDto;
           }

PreparationStandardDataContAndCycleComRespDto retData = new PreparationStandardDataContAndCycleComRespDto();
  if(obtainCurrentTargetContexeCuteCycleComRespDto_1!=null){
      retData.setCycleTypeCode(obtainCurrentTargetContexeCuteCycleComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1612883_1
    }
if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setEvaluationSubjectId(omsEvaluationObjectTargetCycle_1.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1612882_1
retData.setTargetCycleContentId(omsEvaluationObjectTargetCycle_1.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1742196_1
    }




return retData;
  }
/**
   * D3查询已提交的财务标准数据详情(公共)[9933]
   * gen by moon at 7/8/2024, 1:27:43 AM
   */
  @Trace(operationName = "D3查询已提交的财务标准数据详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySubmitFinanceStandardDataDetailComRespDto querySubmitFinanceStandardDataDetailCom(QuerySubmitFinanceStandardDataDetailComReqDto reqDto){


      QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto_1 =null;
ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
//步骤0: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1923415_1
receptionServiceReq.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1922918_1
receptionServiceReq.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1922919_1
    }

    /*M3接收入参字段[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getUpdateCycleId(),"D3查询已提交的财务标准数据详情(公共)-M3接收入参字段-更新周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEntityId(),"D3查询已提交的财务标准数据详情(公共)-M3接收入参字段-归属内容表主键ID不能为空",false);
Assert.isNull(receptionServiceReq.getThemeContentId(),"D3查询已提交的财务标准数据详情(公共)-M3接收入参字段-主题内容ID不能为空",false);
      receptionServiceRes = nbStandardData.implementElevenReceivingField(receptionServiceReq);




//步骤1: D4查询归属主体标准数据详情(公共) - queryStandardDataOfObjectDetailCom
     QueryStandardDataOfObjectDetailComRespDto queryStandardDataOfObjectDetailComRespDto = null;
    QueryStandardDataOfObjectDetailComReqDto queryStandardDataOfObjectDetailComReqDto=new QueryStandardDataOfObjectDetailComReqDto();
  queryStandardDataOfObjectDetailComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1920277_1
queryStandardDataOfObjectDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1920592_1
queryStandardDataOfObjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1920593_1
if(reqDto!=null){
      queryStandardDataOfObjectDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1920591_1
queryStandardDataOfObjectDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1923413_1
queryStandardDataOfObjectDetailComReqDto.setThemeContentId(reqDto.getThemeContentId());//SimpleFieldAssign//sourceId:1920282_1
    }

    /*D4查询财务预算支出金额[8850]   */
    Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getEntityId(),"D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getUpdateCycleId(),"D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-更新周期ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataType(),"D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-数据点类型不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getDataUsageSceneCode(),"D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getThemeContentId(),"D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataOfObjectDetailComReqDto.getSubjectLifeCycle(),"D3查询已提交的财务标准数据详情(公共)-D4查询财务预算支出金额-主体生命周期不能为空",false);
      queryStandardDataOfObjectDetailComRespDto = fwCalcStandardDataClient.queryStandardDataOfObjectDetailCom(queryStandardDataOfObjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤2: D7查财务科目详情(公共) - queryAccountSubjectDetailCom
     QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto = null;
    if(queryStandardDataOfObjectDetailComRespDto !=null){
          QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto=new QueryAccountSubjectDetailComReqDto();
  if(queryStandardDataOfObjectDetailComRespDto!=null){
      queryAccountSubjectDetailComReqDto.setAccountSubjectld(queryStandardDataOfObjectDetailComRespDto.getExtendedField5());//SimpleFieldAssign//sourceId:1920570_1
    }

    /*D7查财务科目详情(公共)[7709]   */

      queryAccountSubjectDetailComRespDto = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryAccountSubjectDetailComRespDto_1 = queryAccountSubjectDetailComRespDto;
           }

//步骤3: M3执行第十一接收字段（特殊方法） - implementElevenReceivingField
     //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    if(queryStandardDataOfObjectDetailComRespDto !=null){
          ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(queryStandardDataOfObjectDetailComRespDto!=null){
      receptionServiceReq_1.setFinanceDataResultId(queryStandardDataOfObjectDetailComRespDto.getDataResultId());//SimpleFieldAssign//sourceId:1922941_1
receptionServiceReq_1.setBudgetDisburse(queryStandardDataOfObjectDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1923423_1
receptionServiceReq_1.setParentBudgetDisburse(queryStandardDataOfObjectDetailComRespDto.getParentDataResult()!=null?String.valueOf(queryStandardDataOfObjectDetailComRespDto.getParentDataResult()):"");//SimpleFieldAssign//sourceId:1923425_1
receptionServiceReq_1.setBudgetDisburseUnit(queryStandardDataOfObjectDetailComRespDto.getUnit());//SimpleFieldAssign//sourceId:1923424_1
    }

    /*M3接收财务数据出参[9482]  用于特殊方法接收上游入参。 */

      receptionServiceRes_2 = nbStandardData.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }

QuerySubmitFinanceStandardDataDetailComRespDto retData = new QuerySubmitFinanceStandardDataDetailComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setFinanceDataResultId(receptionServiceRes_3.getFinanceDataResultId());//SimpleFieldAssign//sourceId:1922947_1
retData.setBudgetDisburse(receptionServiceRes_3.getBudgetDisburse());//SimpleFieldAssign//sourceId:1923429_1
retData.setBudgetDisburseUnit(receptionServiceRes_3.getBudgetDisburseUnit());//SimpleFieldAssign//sourceId:1923430_1
retData.setParentBudgetDisburse(receptionServiceRes_3.getParentBudgetDisburse());//SimpleFieldAssign//sourceId:1923431_1
    }
if(queryAccountSubjectDetailComRespDto_1!=null){
      retData.setAccountSubjectld(queryAccountSubjectDetailComRespDto_1.getAccountSubjectld());//SimpleFieldAssign//sourceId:1922953_1
retData.setAccountSubjectName(queryAccountSubjectDetailComRespDto_1.getAccountSubjectName());//SimpleFieldAssign//sourceId:1922954_1
    }




return retData;
  }

    //
}
